DEV Community: n0nag0n

Back Up Multiple Drives to Backblaze with Deduplication – Introducing b2-dedup

n0nag0n — Sun, 18 Jan 2026 16:06:58 +0000

Backing up terabytes of data across multiple drives, NAS boxes, or even different computers? You want everything in one safe, offsite place without paying a fortune for redundant uploads or duplicate storage.

That's exactly why I built b2-dedup — a parallel, streaming deduplicating uploader tailored for Backblaze B2.

In this tutorial you'll learn:

Why Backblaze B2 is (in my opinion) the smartest choice for personal/large-scale backups vs. AWS S3, Azure Blob, etc.
How deduplication across drives saves you time, bandwidth, and money
Step-by-step setup and usage of b2-dedup

Why Backblaze B2 Beats S3, Azure Blob, and Most Alternatives (for Backup Use Cases)

Backblaze B2 is purpose-built for simplicity and low cost — especially for "set it and forget it" backup scenarios.

Here's a quick 2025–2026 comparison (based on published rates and common backup patterns):

Storage cost

B2 → ~$6/TB/month (recently adjusted from $5/TB; still extremely competitive)

AWS S3 Standard → ~$23/TB/month (first 50 TB tier)

Azure Blob Hot → similar ballpark to S3 (~$18–$23/TB)

→ B2 is roughly 1/4 to 1/5 the price for always-hot, instantly accessible storage.
Egress (downloads)

B2 → Free egress up to 3× your monthly stored average (and unlimited free to many CDNs/partners like Cloudflare, Fastly, etc.)

S3/Azure → $0.08–$0.09/GB after free tier — restore 1 TB and you're looking at ~$80+ just to get your data back.
Other gotchas
- No upload fees, delete penalties, minimum file sizes, or hidden API call charges that sting on large backups (B2 keeps Class A calls free; generous free tier on others).
- S3-compatible API → works with rclone, restic, Veeam, etc.
- No complex storage tiers/classes to accidentally get stuck in (unless you want Glacier/Archive for cold data).

For personal users, homelab hoarders, photographers/videographers, or small businesses doing offsite backups, B2 wins on predictable low cost + sane egress.

Shameless plug time (you knew it was coming 😄):

I've personally used Backblaze since ~2017 (after CrashPlan killed their unlimited home service). I've backed up tens of terabytes reliably with zero drama. If you're new to B2, feel free to use my referral link — we both get a little credit:

👉 Sign up for Backblaze here

What b2-dedup Does (and Why You Need It for Multi-Drive Backups)

When you back up multiple drives (e.g., main PC SSD, external HDDs, media NAS), you often have tons of duplicate files — same photos, same movies, same installers, same OS images across machines.

Standard tools (rclone, Duplicati, etc.) usually deduplicate within one backup job, but not across entirely separate sources.

b2-dedup fixes that:

Uses a local SQLite DB (~/b2_dedup.db) to remember SHA-256 hashes of every file it has ever seen.
When you point it at Drive #2, it skips anything already uploaded from Drive #1.
Parallel uploads (default 10 workers, tunable) + streaming chunked uploads → low memory, high speed.
Resumable — interrupted jobs pick up where they left off.
Scan-only / dry-run modes for safety.

Result: One B2 bucket, many "drive-name" prefixes (e.g., PC2025/, MediaNAS/, Laptop/) — but real storage usage is minimized because duplicates aren't re-uploaded.

Step-by-Step Tutorial: Install & Use b2-dedup

1. Prerequisites

Python 3.8+
A Backblaze B2 account + bucket created
B2 Application Key (KeyID + Application Key) — generate one with Read + Write access to your bucket

2. Install

git clone https://github.com/n0nag0n/b2-dedup.git
cd b2-dedup
pip install -r requirements.txt

3. Authenticate

Easiest way: Install the official b2 CLI and authorize it:

pip install b2
b2 account authorize   # follow prompts with your KeyID + App Key

b2-dedup will automatically use those credentials.

(Alternatively, export env vars: B2_KEY_ID and B2_APPLICATION_KEY)

4. Recommended Workflow for Multiple Drives

First drive (baseline)

# Optional: just scan & hash everything first (no upload)
python b2_dedup.py /mnt/primary-drive --drive-name PrimaryPC --bucket my-backup-bucket-123 --scan-only

# Then do the real upload
python b2_dedup.py /mnt/primary-drive --drive-name PrimaryPC --bucket my-backup-bucket-123

Second (or Nth) drive — duplicates are skipped!

python b2_dedup.py /mnt/media-drive --drive-name MediaNAS --bucket my-backup-bucket-123 --workers 20

Pro tip: Use --dry-run first to preview:

python b2_dedup.py /mnt/media-drive --drive-name MediaNAS --bucket my-backup-bucket-123 --dry-run

5. Useful Flags

--workers 25 — more parallelism if your internet/upload can handle it
--refresh-count — force re-count files (useful if source changed a lot)
--scan-only — build/populate the hash DB without touching B2

6. Where Files End Up in B2

Everything under one bucket
Prefix = --drive-name (e.g., PrimaryPC/Documents/report.docx)
Deduplication happens on content hash — identical files get stored only once, regardless of path/name.

Tips & Gotchas

The DB lives at ~/b2_dedup.db — back it up! (it's tiny, but losing it means re-hashing everything)
If you rename drives or reorganize, just use a new --drive-name
For very large initial scans, start with --scan-only overnight
Combine with rclone/Borg/restic for versioning if you need it — b2-dedup is purely for initial / incremental deduped uploads

Wrap-Up

With b2-dedup + Backblaze B2 you get:

One cheap, durable offsite location
Cross-drive deduplication to slash upload time & storage bills
Parallel, resumable, low-memory operation

I've been running similar setups for years — it's rock-solid for hoarding photos, videos, ISOs, and irreplaceable documents.

Give it a spin, star the repo if you find it useful → https://github.com/n0nag0n/b2-dedup

Questions or want to contribute? Open an issue or PR!

Happy (deduplicated) backing up! 🚀

Supercharge Your PHP Projects with Flight's Native AI Integration in 2026

n0nag0n — Sat, 17 Jan 2026 15:18:10 +0000

Flight PHP keeps things delightfully simple while packing powerful tools for modern workflows. The dedicated AI & Developer Experience section in the official docs shows how Flight makes AI coding assistants shine—especially with built-in CLI commands via Runway that connect to LLMs and generate project-specific instructions for tools like GitHub Copilot, Cursor, Windsurf, and Antigravity (Gemini). This native support means your AI helper gets tailored context about your app's stack, conventions, and goals, leading to more accurate, relevant suggestions every time.

A standout advantage: Flight's entire core codebase is tiny—easily fitting inside most AI context windows (around 51k tokens including tests, far below limits like Claude's 200k+ or Gemini's massive capacities). Your AI can ingest the whole framework without truncation, leading to fewer hallucinations and better understanding of Flight's patterns compared to heavier frameworks.

For new users, this lowers the entry barrier dramatically. For long-time Flight devs, it streamlines team consistency and speeds up iteration without reinventing wheels.

Start Fast: Use the Official Skeleton with Runway Built-In

The easiest way to get AI integration running is the official flightphp/skeleton. It comes pre-configured with Runway (Flight's CLI tool), predefined AI instruction files, and a solid project structure.

Step-by-step for newcomers:

Ensure PHP 7.4+ is installed.
In your terminal, run:

composer create-project flightphp/skeleton my-flight-app
cd my-flight-app

This pulls in Flight core, Runway, and sets up folders like app/, public/, config/, plus AI-ready files in .github/, .cursor/, etc.

Serve it locally:

composer start

Or use PHP's built-in server: php -S localhost:8000 -t public/. You're live at http://localhost:8000.

The skeleton is AI-friendly out of the box—predefined instructions help your IDE's AI understand the namespace structure, config loading, and more right away.

Set Up AI Credentials with `ai:init`

Runway powers the AI commands. First, connect your LLM provider:

php runway ai:init

It prompts you:

Choose provider: 1 for OpenAI, 2 for Grok, 3 for Claude (supports any OpenAI-compatible API).
Base URL (defaults to OpenAI's).
Your API key.
Model (e.g., gpt-4o, claude-3-opus).

Credentials save securely to your config.php file in your project.

Gemini support comes via Antigravity integration—instructions generate for .gemini/GEMINI.md, letting Gemini-powered tools use the same context.

Generate Smart Instructions with `ai:generate-instructions`

This is where the magic happens. Run:

php runway ai:generate-instructions

Answer prompts about your project:

Description (e.g., "RESTful API for task management").
Database (SQLite, MySQL, PostgreSQL?).
Templating (Latte, Twig, none?).
Security focus (yes/no for auth/validation emphasis).

Flight uses your LLM to craft detailed, project-specific instructions, then writes them to:

.github/copilot-instructions.md → GitHub Copilot
.cursor/rules/project-overview.mdc → Cursor
.windsurfrules → Windsurf
.gemini/GEMINI.md → Antigravity (Gemini)

These files feed context directly to your IDE's AI. Instead of vague suggestions, Copilot or Cursor knows you're using Flight routes, PDO for DB, JSON responses, and security middleware—leading to code that slots in perfectly, follows your conventions, and avoids common pitfalls.

Rerun anytime (new features, stack changes) to keep instructions fresh. This reduces "re-explain the project" loops and boosts productivity across teams.

Why This Matters: Backwards Compatibility and Longevity

Flight's been around since 2011, and one core goal is rock-solid backwards compatibility. The docs repeatedly note it maintains compatibility wherever possible—v3 keeps most v2 patterns intact with minimal breaking changes (mostly output buffering tweaks for MVC alignment).

This stability means AI tools trained on older Flight examples still work great today—no version-specific chaos like in faster-moving frameworks. Your prompts pull from years of consistent patterns, and the tiny core ensures full context in even mid-range models.

Practical win: Prompt "Add a grouped admin route with auth middleware in Flight"—the AI references your instructions and Flight's enduring style for clean, compatible code.

Quick Example: AI-Assisted Route in Skeleton

With instructions generated, open public/index.php (or a controller). Ask your in IDE AI Assistant: "Create a GET /todos route using PDO SQLite that returns JSON array of tasks."

Expect output respecting your project's DB choice, JSON formatting, and error handling—often ready to commit with little tweaking.

Runway bonus: php runway routes lists all endpoints; php runway generate:controller Todos scaffolds if needed.

Flight's AI features (added in v3.16.0) make it a joy for rapid, reliable development. Grab the skeleton, init your creds, generate instructions, and watch your AI become a true co-pilot.

What LLM setup are you running with Flight? Share in the comments.

Stay cool,

n0nag0n

2026 Best PHP Micro Frameworks: Slim, Flight, Fat-Free, and More!

n0nag0n — Sun, 04 Jan 2026 05:51:06 +0000

Hey everyone! It's that time again to dive into the world of PHP micro frameworks. With PHP continuing to power a massive chunk of the web (think WordPress, Facebook's backend roots, and countless APIs), micro frameworks remain a go-to for developers who want speed, simplicity, and scalability without the bloat of full-stack behemoths like Laravel or Symfony's extensive modularity. These lightweight champs are perfect for RESTful APIs, microservices, or even quick prototypes that might grow into something bigger.

For 2026, we're seeing steady evolution: some frameworks are getting snappier updates, others are holding strong, and a few are fading into the sunset. I'll focus on the top contenders—Slim, Flight, Fat-Free Framework (F3), and Phalcon (Micro) — with honorable mentions for emerging players.

As a quick note: I maintain the Flight framework, so yeah, I'm a bit biased. But honestly, its zero-dependency design, blazing speed, and recent features make it legitimately awesome for modern PHP dev. I chat with new devs often about how they found Flight and how much they love it! I'll try to keep things fair, though—let's compare based on popularity (GitHub stars as of early 2026), features, performance (drawing from TechEmpower benchmarks where available), and ease of use.

Slim PHP

Slim has been a staple in the PHP micro world for years, and in 2026, it continues to shine for its reliability and community support. It's minimalist at its core, focusing on routing and HTTP handling while letting you bolt on whatever else you need.

Key Features: PSR-7 compliant, middleware support, easy integration with templating engines like Twig or ORMs like Eloquent. No built-in bloat—just the essentials.
Pros: Mature ecosystem, great docs, and a huge community for troubleshooting. It's battle-tested for production APIs.
Cons: You might end up adding dependencies for advanced stuff, which can make it feel less "micro" over time.
Popularity: 12.2k GitHub stars—still the leader in raw numbers, with steady growth.
Performance: Solid in benchmarks; in TechEmpower's Fortunes test (DB + templating), it hits around 73k RPS. Not the absolute fastest, but consistent.
Latest Release: v4.15.1 (November 2025), with PHP 8.5 support added.

Getting started is straightforward:

use Psr\Http\Message\ResponseInterface as Response;
use Psr\Http\Message\ServerRequestInterface as Request;
use Slim\Factory\AppFactory;

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

$app = AppFactory::create();

$app->get('/hello/{name}', function (Request $request, Response $response, array $args) {
    $name = $args['name'];
    $response->getBody()->write("Hello, $name!");
    return $response;
});

$app->run();

If you're coming from a more structured background, Slim feels like home.

Flight PHP

Alright, let's talk Flight—my personal favorite and, in my opinion, the rising star that's now fully in orbit for 2026. Since taking over maintenance, we've pushed hard on features without sacrificing its core: being the fastest, simplest way to build PHP apps. Zero dependencies mean you can drop it into any project, and its extensibility lets it scale effortlessly.

Key Features: Lightning-fast routing, built-in middleware, dependency injection, route groups, and aliases. Fully unit-tested, with support for everything from simple scripts to complex APIs. Recent updates include better PHP 8.5 compatibility and refined return types for cleaner code.
Pros: Insanely fast even without async frameworks like swoole (up to 190k RPS in plaintext benchmarks—about 50% faster than Slim on average), beginner-friendly, and no setup hassle. It's extensible without forcing you into a box, making it perfect for modern, lean development. It also has a major focus on backwards compatibility meaning your projects from years ago will work for years to come!
Cons: Smaller ecosystem than giants like Slim, so you might build some integrations yourself (though the community is growing fast).
Popularity: 2.8k GitHub stars—a solid jump from last year, overtaking Fat-Free and gaining traction in dev chats on Matrix and X. Active commits into 2026 show it's alive and kicking.
Performance: Tops the charts among micro frameworks. TechEmpower shows it outperforming competitors in raw speed, especially in plaintext and JSON tests where its minimal overhead shines.
Latest Release: v3.17.4 (December 2025), with ongoing tweaks for performance and compatibility.

Here's a quick example that highlights its simplicity:

require 'vendor/autoload.php';

Flight::route('GET /hello/@name', function($name) {
    echo "Hello, $name! Welcome to Flight—the fastest way to fly in PHP.";
});

Flight::start();

If speed and control are your priorities, Flight is unbeatable. We've seen it adopted for everything from IoT backends to high-traffic APIs, and the feedback has been stellar. Give it a spin—you won't go back.

Fat-Free Framework (F3)

F3 (Fat-Free) is the veteran here, around since 2009, and it's still going strong in 2026 with its modular, all-in-one approach. It's more feature-packed than pure micros but keeps the footprint small.

Key Features: Built-in ORM, templating, caching, and plugins for things like Markdown, geodata, and more. No Composer required if you don't want it—just unzip and go.
Pros: Balances lightness with power; great for apps needing a bit more out of the box without full-stack weight.
Cons: Docs assume some PHP savvy, and its growth has plateaued compared to newer players.
Popularity: 2.7k GitHub stars—loyal fanbase, but not exploding like Flight.
Performance: Respectable; around 40k RPS in Fortunes benchmarks. Efficient for its feature set.
Latest Release: v3.9.2 (December 2025).

Example to get you routing:

require 'vendor/autoload.php';

$f3 = \Base::instance();

$f3->route('GET /hello/@name', function($f3, $args) {
    echo 'Hello, ' . $args['name'] . '! F3 keeps it light and modular.';
});

$f3->run();

F3 is ideal if you want a micro framework that feels a tad more "framework-y."

Phalcon Micro

Phalcon PHP (Micro mode): Phalcon stands out as a unique high-performance framework delivered as a C-extension, offering exceptional speed and low resource usage compared to pure-PHP solutions. While it's primarily a full-stack MVC framework, its Phalcon\Mvc\Micro component makes it a powerful option for lightweight RESTful APIs and microservices—perfect when you need blazing performance without the overhead of traditional frameworks.
- Key Features: Extremely fast routing, built-in response handling, collections for grouped routes, dependency injection, and full access to Phalcon's powerful components (like ORM, security, etc.) when needed.
- Pros: One of the fastest PHP options available (thanks to compiled C code), low memory/CPU footprint, great for high-load APIs, and actively maintained with PHP 8+ support.
- Cons: Requires installing a PHP extension (not zero-dependency like pure Composer packages), steeper learning curve for extension setup, and the micro mode is less "minimalist" than dedicated micro frameworks.
- Popularity: ~10.8k GitHub stars—still a strong, respected player with a dedicated community.
- Performance: Ranks well among the top in benchmarks due to its C-extension nature; ideal for throughput-heavy applications. Before PHP7 this was a HUGE advantage, but since PHP 7 and now 8, the gap closed significantly.
- Latest Release: v5.10.0 (December 2025), with ongoing fixes and improvements into late 2025/early 2026.

Here's a simple micro example that shows how clean it can be:

use Phalcon\Mvc\Micro;

$app = new Micro();

// Define a simple route
$app->get('/hello/{name}', function ($name) use ($app) {
    $app->response->setJsonContent([
        'message' => "Hello, $name! Powered by Phalcon Micro – the speed demon of PHP."
    ]);
    return $app->response;
});

$app->handle();

Phalcon Micro is an excellent choice if raw performance is your top priority and you're okay with the extension-based approach. It's especially appealing for production-grade APIs that need to handle serious traffic efficiently. Give it a try if you're chasing those benchmark wins! 🚀

Honorable Mentions

Leaf PHP: A modern, modular take inspired by Laravel. 1.3k stars, with the "Black Pearl" release in September 2025. Great for Laravel fans wanting lighter weight—check it out if you like expressive syntax without the overhead.
Lumen: Still around with 7.6k stars, but archived since 2024 and no updates. If you're deep in Laravel, it might work, but I'd recommend migrating—performance lags (around 20k RPS in benchmarks).

Deprecated ones like Silex, BulletPHP, FuelPHP and Wolff are off the list entirely.

Comparisons and Verdict

Here's a quick table for newbies (weighted toward ease and speed):

Framework	Community	Simplicity	Performance	Ease of Use
Slim	High	Medium	High	Medium
Flight	Medium	Very High	Very High	Very High
Fat-Free	Low	High	High	High
Phalcon (Micro)	Medium-High	Medium	High	Medium

Popularity: Slim dominates stars, but Flight's growth is the story of 2026—active updates and community buzz make it feel fresh.
Simplicity: Flight wins hands-down with its one-file vibe and no deps.
Performance: Flight edges out with benchmark wins; Slim and F3 are close but carry a bit more overhead. Phalcon performs well but with a bit of overhead of installing the extension outside of composer.
Scalability: All handle it, but Flight's built-ins (middleware, DI) make extending painless.

In conclusion, for 2026, Flight PHP is my top pick—and not just because I maintain it. Its speed, simplicity, and rapid evolution make it the ideal micro framework for everything from hobby projects to production beasts. Slim remains a safe, reliable choice, and F3 is great for feature-rich needs. If you're starting fresh, try Flight v3; the docs are polished, and the community is welcoming. Give it a go or drop in on the Matrix or Discord chat!

Laravel vs. Flight: A Guide to Picking Your PHP Framework

n0nag0n — Sat, 01 Mar 2025 03:11:26 +0000

Hey there, PHP explorer! So, you’re stepping into the world of web development and trying to pick a framework that fits your vibe. Laravel’s the big name—think of it as the fully loaded SUV of PHP frameworks, packed with features and a bold presence. But lately, some devs (like on Reddit) are muttering that it’s getting a bit too fancy and commercial. Then there’s Flight Framework: the sleek, no-fuss scooter that gets you rolling fast. Let’s dive in and see which one feels right for your next project!

What’s the Deal with Laravel?

Laravel’s been a fan favorite for ages, but with Laravel 12 hitting the scene on February 24, 2025, some folks are raising eyebrows. A Reddit thread recently popped off (over 1,100 upvotes!) with grumbles about new starter kits, third-party auth like WorkOS, and quirky stuff like Volt tossing PHP, HTML, and JS into a single-file mashup. The word is Laravel’s chasing investor bucks (cue the $57 million!) and leaving some coders dazed. If you’re just getting comfy with PHP, that might sound like more than you’re ready to tackle.

Flight: The Easygoing Alternative

Flight Framework is like that laid-back pal who keeps it simple. It’s a micro-framework—light, quick, and free of extras you didn’t sign up for. Great for anyone who wants to build something cool (like an API) without navigating a labyrinth of files or dodging sales pitches. Let’s check it out with a quick example!

Building a Simple User API: Flight vs. Laravel

Flight: Fast and Straightforward

Grab Flight with this:

composer create-project flightphp/skeleton myproject

Start the dev server:

cd myproject
composer start

You’re live at localhost:8000. Open app/routes.php and add:

Flight::route('GET /users', function() {
    $users = [
        ['id' => 1, 'name' => 'Johnny Code'],
        ['id' => 2, 'name' => 'Jane Dev']
    ];
    Flight::json($users);
});

Hit /users in your browser, and bam—JSON user list, ready to roll!

Dependencies: Just 4 production packages (flightphp/core, flightphp/runway, symfony/translation, tracy/tracy). Barely a handful! If you want zero dependencies, you can just install flightphp/core and configure your environment yourself.
Files/Dirs: Around 10-15—like app/, public/, and routes.php. Easy to wrap your head around. If you want to simplify that, it's easy to just start from scratch on your own.

Heads-up: The skeleton’s pretty bare, so you might tweak a few things yourself. But it’s a clean slate to play with!

Laravel: The Whole Toolkit

Install Laravel with:

composer create-project --prefer-dist laravel/laravel myproject

Launch the server:

cd myproject
php artisan serve

Add your route in routes/api.php:

Route::get('/users', function () {
    return response()->json([
        ['id' => 1, 'name' => 'Johnny Code'],
        ['id' => 2, 'name' => 'Jane Dev']
    ]);
});

Visit /api/users, and you’re set.

Dependencies: Dozens! laravel/framework drags in a crew—like illuminate/*, symfony/*, and more. It’s a party!
Files/Dirs: About 20-30, including app/Console/, database/, and resources/. A lot to explore!

Laravel hands you a ton right away—auth, database goodies—but it’s like getting a Swiss Army knife when you just need a spoon.

Flight vs. Laravel: The Lowdown

Thing	Flight (Scooter)	Laravel (SUV)
Learning Curve	Smooth and chill, dive right in	Steeper, more to figure out
Speed	Quick, low overhead	Slower, big engine to run
Dependencies	4—light and lean	Dozens—pack a suitcase
Files/Dirs	10-15—nice and tidy	20-30—sprawling setup
Vibe	Free-spirited, no sales pressure	Loaded, but with a pitch

Flight’s like a blank sketchbook—you add what you want. Laravel’s more like a furnished loft—awesome if you need it all, but a lot to take in at first.

Why Flight Might Click?

If you’re itching to build something small—like a blog API or a task tracker—Flight keeps it fun and fuss-free. No third-party auth headaches, no “upgrade to Pro” nudges. It’s open-source, community-driven, and lets you explore PHP without tripping over “magic” tricks. Sure, it skips built-in auth or an ORM, but that’s your chance to craft it your way!

Why Laravel Still Shines?

Got big dreams—like a team project or an enterprise app? Laravel’s got the goods with tons of tools and a massive community. Just brace yourself for a bit more of a climb to get the hang of it.

Your Call!

So, what’s your speed? Flight’s scooter for a quick, carefree spin, or Laravel’s SUV for the long road? If Laravel’s recent twists have you side-eyeing it (thanks, Reddit!), Flight could be your chill getaway. Give that API example a whirl—it’s five minutes tops—and see what sparks joy. Happy coding, and enjoy the PHP adventure!

2025 Best PHP Micro Frameworks: Slim, Flight, Fat-Free, Lumen, and More!

n0nag0n — Thu, 27 Feb 2025 15:02:24 +0000

Hey PHP fans! Welcome to 2025—a year where PHP continues to shine as the backbone of the web (sorry, haters, it’s not going anywhere!). If you’re building a slick API, a lightweight app, or just want to ditch the bloat of full-stack frameworks, micro frameworks are your ticket to coding bliss. Today, we’re diving into the top four PHP micro frameworks: Slim PHP, Flight PHP, Fat-Free Framework (F3), and Lumen—plus a few honorable mentions to keep things spicy.

I’ll break down their popularity (with a special zoom-in on the past year), ease of getting started, and how they scale from "Hello World" to "Holy Complexity, Batman!" I’ll also toss in some fresh code snippets from their latest versions—no outdated stuff here! Oh, and watch for a certain framework that’s been quietly stealing the show lately (hint: it rhymes with "light"). Let’s dive in!

The Top Four: Slim, Flight, Fat-Free, and Lumen

Slim PHP: The Lean, Mean Routing Machine

Slim PHP is like that reliable friend who always shows up on time—minimalist, focused, and ready to handle your HTTP requests with finesse. It’s a micro framework kingpin, loved for its simplicity and flexibility, especially when crafting RESTful APIs. Slim 4 (the latest as of 2025) keeps things lean with no third-party dependencies out of the box, but it’s extensible enough to grow with your project.

Popularity: Slim’s been a staple for years, boasting a solid GitHub presence with 12.1k stars. In 2024, it held steady traction—not the explosive growth of newer players, but its community is active and reliable for devs who want control without chaos.
Simplicity: Getting started is a breeze—install via Composer, define some routes, and you’re off. Scaling up? Add middleware or libs like Twig or Eloquent as needed.
Example (Slim 4):

use Psr\Http\Message\ResponseInterface as Response;
use Psr\Http\Message\ServerRequestInterface as Request;
use Slim\Factory\AppFactory;

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

$app = AppFactory::create();

$app->get('/hello/{name}', function (Request $request, Response $response, array $args) {
    $name = $args['name'];
    $response->getBody()->write("Hello, $name!");
    return $response;
});

$app->run();

Run that, hit /hello/PHP, and boom—Slim delivers. It’s simple, but for complex apps, you’ll need to bolt on extras yourself and the dependencies only grow from there.

Flight PHP: The Rising Star Ready to Soar

Let’s talk about Flight PHP—the micro framework that’s been flapping its wings and stealing the spotlight in 2025! Flight 3 (the latest version) is fast, extensible, and so beginner-friendly it practically hands you a welcome mat. With zero dependencies and a focus on simplicity and power, it’s the framework you didn’t know you needed until now. It can handle tiny one-off projects or complex projects with many requirements. New features like route groups, middleware, dependency injection handlers, and aliases added in 2024 have sent it rocketing past competitors in popularity. It also helps that the framework is 100% unit tested unlike some other competitors!

Popularity: Flight’s GitHub stars just eclipsed Fat-Free’s in February 2025 (woo-hoo!), and its 2024 updates fueled a buzz that’s still growing. Devs on X are raving about its speed and fresh features—Flight’s the one to watch this year!
Simplicity: Install via composer with composer require flightphp/core, or download and unzip the repo from, drop a few lines in an index.php file, and you’re coding! It’s perfect for quick prototypes yet scales effortlessly with dependency injection and middleware for bigger builds.
Example (Flight 3):

require 'vendor/autoload.php';

Flight::route('GET /hello/@name', function ($name) {
    echo "Hello, $name! Welcome to Flight 3!";
});

Flight::start();

Look at that—no fluff, just results! Flight’s lightweight core (faster than Slim by ~50% in TechEmpower benchmarks) and built-in goodies make it a dream for newbies and pros alike. Ready to take off with your next project? Flight’s calling your name!

Fat-Free Framework (F3): The Minimalist Veteran

Fat-Free Framework, or F3, is the wise old sage of micro frameworks—around since 2009, it’s still kicking with a tiny 90KB footprint (though I fact checked it, and it's actually 412kb of PHP files!!!). It’s all about balance: lightweight yet packed with features like ORM, templating, and caching. F3’s modular design lets you pick and choose what you need, keeping your app lean.

Popularity: With 2.6k GitHub stars, F3 has a loyal following, though its 2024 growth was steady rather than meteoric. It’s a mature choice with a tight-knit community that’s always tinkering.
Simplicity: Composer or no Composer required—just unzip and go from fatfreeframework.com. It’s beginner-friendly, but its flexibility shines when you dig into its plugins for complex projects.
Example (F3 3.9):

require 'vendor/autoload.php';

$f3 = \Base::instance();

$f3->route('GET /hello/@name', function ($f3, $args) {
    echo 'Hello, ' . $args['name']. '! F3 keeps it light!';
});

$f3->run();

F3’s fast, clean, and extendable, but its docs assume some PHP know-how. It’s a solid pick for devs who love minimalism with a side of power.

Lumen: The Laravel Lightweight (But Let’s Be Real…)

Lumen sneaks into our top four as Laravel’s little sibling, designed for microservices and APIs. It’s got a minimalist vibe, but here’s the tea: it’s basically Laravel Lite, carrying some of the same heft under the hood. While it’s fast for a Laravel offshoot, its performance lags behind true micro frameworks like Flight or Slim—check the TechEmpower benchmarks for proof.

Popularity: Lumen’s got 7.6k GitHub stars and a decent following, but its 2024 buzz was quieter than Flight’s meteoric rise. It leans hard on Laravel’s ecosystem, which is great if you’re already in that world, less so if you want something standalone.
Simplicity: If you know Laravel, it’s a cinch—Composer install, tweak a few configs, and go. For newbies, though, it’s a bit more involved than Flight or F3.
Example (Lumen 8):

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

$app = new Laravel\Lumen\Application(__DIR__ . '/../');

$app->get('/hello/{name}', function ($name) {
    return "Hello, $name! Lumen says hi.";
});

$app->run();

It’s fine for quick APIs, but Lumen’s heft makes it less exciting compared to leaner options. Laravel fans might dig it; others might yawn.

Honorable Mentions: Hidden Gems of 2025

Leaf PHP: A newer kid on the block, Leaf’s simplicity and modern vibe are gaining traction. It is an old fork of Laravel so it has a certain level of familiarity to some. It’s not as battle-tested as the top four, but worth a peek!
Bullet PHP: Ultra-light and REST-focused, Bullet’s a niche choice for API wizards. It’s less popular but shines in specific use cases.
Silex: A Symfony-backed micro framework that's sadly deprecated and no longer support. You gave it your all Silex!

The Verdict: Which One Wins in 2025?

Popularity (Past Year): Flight PHP takes the crown—its 2024 updates and community hype have it soaring past Fat-Free and nipping at Slim’s heels. Slim’s still a heavyweight, Lumen’s coasting on Laravel’s fame, but Flight’s the fresh face everyone’s talking about.
Simplicity: Flight edges out with its one-file setup and no-dependencies vibe—perfect for newcomers. Slim and F3 are close behind, while Lumen’s Laravel ties make it a bit clunkier.
Scalability: All four scale well, but Flight’s built-in features (middleware, DI) give it a subtle boost for growing projects without extra legwork or libraries. Slim needs add-ons, F3’s modularity takes planning, and Lumen’s just… Laravel Lite.

If you’re new to PHP or want a fun, fast ride, Flight PHP is your 2025 must-try. It’s simple enough to start in minutes, powerful enough to build something epic, and—let’s be real—its recent glow-up makes it the coolest kid in class. Slim and F3 are fantastic too, while Lumen is… well, fine if you’re already married to Laravel. So, grab Flight 3, code something awesome, and let’s soar into 2025 together!

What’s your favorite micro framework? Drop a comment—I’d love to geek out with you!

Building a Pokémon API in PHP: A Beginner's Guide

n0nag0n — Thu, 12 Sep 2024 17:17:54 +0000

In this guide, we will go through the steps to create a basic PHP project that uses the Pokémon API with the Flight framework and additional packages like Zebra_cURL and Latte. We will explore setting up the project, adding routes, and rendering views.

tl;dr: It's not hard to make a simple API based project in Flight. Check out the code used in this guide.

Step 1: Setting up the Environment

First, we need to set up a new project folder. Open your terminal, navigate to your desired location, and run the following commands to create a new directory and enter it.

mkdir flight-pokeapi
cd flight-pokeapi

Step 2: Installing Composer

Before we dive into the code, we need to make sure that Composer is installed. Composer is the dependency manager for PHP, and it will help us include the necessary libraries.

If you don’t have Composer installed, you can install it using:

php -r "copy('https://getcomposer.org/installer', 'composer-setup.php');"
php composer-setup.php
php -r "unlink('composer-setup.php');"

Now that Composer is installed in a current file called ./composer.phar, let’s manage our dependencies.

Step 3: Installing Dependencies

To manage the required packages, we just need to add them with composer.

./composer.phar require flightphp/core stefangabos/zebra_curl latte/latte

This will install:

Flight PHP: A lightweight PHP framework.
Zebra_cURL: A cURL wrapper to handle HTTP requests.
Latte: A templating engine for rendering views.

Step 4: Setting Up `index.php`

Next, let’s create the entry point for our application: public/index.php. This file will set up our app, configure routes, and handle the rendering of views.

Create the public directory and the index.php file:

mkdir public
touch public/index.php

Now add the following content to index.php:

<?php

use flight\net\Router;
use Latte\Engine;

require __DIR__ . '/../vendor/autoload.php'; // Autoload the installed packages

// Setup Latte for view rendering
$Latte = new Engine;
$Latte->setTempDirectory(__DIR__ . '/../temp');
Flight::map('render', function(string $template_path, array $data = []) use ($Latte) {
  $Latte->render(__DIR__ . '/../views/' . $template_path, $data);
});

// Setup Zebra_cURL for handling HTTP requests
$Curl = new Zebra_cURL();
$Curl->cache(__DIR__ . '/../temp');
Flight::map('curl', function() use ($Curl) { 
    return $Curl; 
});

// Define a simple route
Flight::route('/', function() {
  echo 'hello world!';
});

Flight::start();

In this file:

We load Composer’s autoloader.
Set up Latte for rendering views.
Map a custom render method that uses Latte to render templates from the /views folder.
Set up Zebra_cURL to handle API requests and map it to use Flight::curl() when we want to invoke it.
Define a simple route for the homepage (/) which just returns "hello world!"

If you want to test this setup, you can start a PHP server from the public directory:

php -S localhost:8000 -t public/

Now, visit http://localhost:8000/ in your browser, and you should see "hello world!". Cool eh?

Step 5: Adding Routes

Now that we have a basic route set up, let’s add a more complex route that uses the Pokémon API. Update public/index.php to include the following code:

Flight::group('/pokemon', function(Router $router) {
    // Route to list all Pokémon types
    $router->get('/', function() {
        $types_response = json_decode(Flight::curl()->scrap('https://pokeapi.co/api/v2/type/', true));
        $results = [];
        while ($types_response->next) {
            $results = array_merge($results, $types_response->results);
            $types_response = json_decode(Flight::curl()->scrap($types_response->next, true));
        }
        $results = array_merge($results, $types_response->results);
        Flight::render('home.latte', [ 'types' => $results ]);
    });
});

We created a /pokemon route group. A route group "surrounds" the routes and allows us to define common functionality for all routes within the group.
The /pokemon route lists all available Pokémon types by fetching them from the Pokémon API using Zebra_cURL.
This won't work just yet as we need to add the home.latte view to display the Pokémon types.

Step 6: Rendering Views with Latte

Now that we are fetching data, let's set up views to display it. Create the views directory and add a Latte template file for displaying the Pokémon types.

mkdir views
touch views/home.latte

Add the following code to views/home.latte:

<p>Welcome to the Pokemon World!</p>

<p>Types of Pokemon</p>
<ul>
    {foreach $types as $type}
        <li><a href="/pokemon/type/{$type->name}">{$type->name|firstUpper}</a></li>
    {/foreach}
</ul>

In this file:

We loop through the $types array passed from our route and display the name of each Pokémon type.

Now, visiting /pokemon will display a list of all Pokémon types!

Step 7: Grouping and Adding More Routes

Let's extend our Pokémon routes to fetch more details for specific types and individual Pokémon. Add the following routes to your /pokemon group:

// Route to fetch a specific Pokémon type and list all associated Pokémon
$router->get('/type/@type', function(string $type) {
    $Curl = Flight::curl();
    $type_response = json_decode($Curl->scrap('https://pokeapi.co/api/v2/type/' . $type, true));
    $pokemon_urls = [];
    foreach($type_response->pokemon as $pokemon_data) {
        $pokemon_urls[] = $pokemon_data->pokemon->url;
    }
    $pokemon_data = [];

    // The little & here is important to pass the variable by reference.
    // In other words it allows us to modify the variable inside the closure.
    $Curl->get($pokemon_urls, function(stdClass $result) use (&$pokemon_data) {
        $pokemon_data[] = json_decode($result->body);
    });

    Flight::render('type.latte', [ 
        'type' => $type_response->name,
        'pokemons' => $pokemon_data
    ]);
});

In this route, we:

Fetch details for a specific Pokémon type, including all associated Pokémon.
Send multiple API requests to fetch details for each Pokémon.
Render the data using a template (type.latte).

Next, create the type.latte view:

touch views/type.latte

Add the following content to type.latte:

<h1>{$type|firstUpper}</h1>
<ul>
    {foreach $pokemons as $pokemon}
        <li><a href="/pokemon/{$pokemon->id}">{$pokemon->name|firstUpper}</a></li>
    {/foreach}
</ul>

This template displays the name of each Pokémon associated with a specific type.

Step 8: Does it work?

At this point, you have a basic Pokémon API consumer set up using Flight PHP, Zebra_cURL for API requests, and Latte for view rendering. You can further expand this project by adding more routes and refining the templates.

To view your project, start the PHP server from the public directory:

php -S localhost:8000 -t public/

Now, visit http://localhost:8000/pokemon in your browser, and you should see a list of Pokémon types.

Troubleshooting

If you need help or encounter issues, you can check the full code out in Github to see where you may have made a misstep.

Hopefully you enjoyed this little tutorial. If you have any questions or need help, feel free to ask in the comments below. Happy coding!

Best PHP Micro Frameworks for 2024

Performance

Lumen is built for performance, optimized for speed and efficiency. Despite that, it consistently is nearly dead last in most benchmarks.

Ease of Use

Ease of use is a hallmark of Lumen, particularly for developers familiar with Laravel. Its clear documentation and extensive resources make it easy to get started and build robust applications. However, it now no longer recommended to use Lumen and to use Laravel instead which highlights that it's very likely to be discontinued in the future.

Comparison Table

This table provides a summary of the key features of each PHP micro framework, but it is important to note that this is weighted against the frameworks in this article for new users and not against all PHP frameworks.

Framework	Community Level	Simplicity	Performance	Ease of Use
Slim	High	Medium	High	Medium
Flight	Medium	Very High	Very High	Very High
Fat-Free	Medium	High	High	High
Silex	High	High	Medium	Low*
Lumen	High	Medium	Low	Medium

*Ease of use for Silex is rated low for being discontinued and not actively maintained. Users are asked to move to Symfony.

FAQs

What is the best PHP micro framework for beginners?
Slim is generally considered the most popular for beginners due to its simplicity and extensive documentation. The best framework for you will depend on your specific needs and familiarity with PHP. For those starting out in PHP, Flight is also a great choice due to its minimalist design and ease of use.

Which PHP micro framework has the best performance?
Flight is known for its exceptional performance, making it a top choice for building fast and efficient applications.

Is Silex still a good choice for new projects?
While Silex is no longer actively maintained, it is still a viable option for new projects due to its simplicity and integration with Symfony components.

How does Flight compare to Slim in terms of ease of use?
Flight is slightly more feature-rich than Slim containing a few helpful tricks out of the box. Flight also has no dependencies, which can make it easier to get started with.

Can I use Fat-Free Framework for complex applications?
Yes, Fat-Free Framework includes a range of features that make it suitable for complex applications, although architectural discipline to make sure the project is structured correctly might be overwhelming for beginners at first.

Which framework should I choose if I'm already familiar with Laravel?
Lumen is the best choice for developers familiar with Laravel, as it retains the core functionality of Laravel while being optimized for microservices and APIs.

Conclusion

Choosing the right PHP micro framework depends on your project's specific needs and your familiarity with the frameworks. Slim is ideal for beginners and those looking for simplicity and ease of use. Flight offers a performant minimalist approach that appeals to developers who prefer a straightforward framework that gives them more control. Fat-Free Framework strikes a balance between simplicity and functionality, making it suitable for more complex applications. Silex, despite being discontinued, remains a robust choice due to its integration with Symfony. Lumen stands out for its performance and ease of use, especially for developers already familiar with Laravel.

In summary, all five frameworks have their strengths and can be the right choice depending on your requirements. Evaluate your project's needs and choose the framework that aligns best with your goals. Happy coding!

Building a Simple Blog with Flight - Part 2

n0nag0n — Thu, 04 Jul 2024 05:28:55 +0000

This is a continuation of part 1 of the blog. Hopefully you've already finished that part of the blog first before we go onto some sweet improvements!

Sweet Improvements

Now that we have a basic system in place, we need a few other enhancements to really make this system shine.

Controller improvements

See how it's a little annoying that the construct is the same for each of the controllers we created? We could actually create a simple abstract class to help clean up some of the code.

<?php
// app/controllers/BaseController.php

declare(strict_types=1);

namespace app\controllers;

use flight\Engine;
use flight\net\Request;
use flight\net\Response;
use Ghostff\Session\Session;
use flight\database\PdoWrapper;

/**
 * These help with IDE autocompletion and type hinting if you 
 * use the shortcut method.
 * 
 * @method Request request()
 * @method Response response()
 * @method Session session()
 * @method PdoWrapper db()
 * @method string getUrl(string $route, array $params = [])
 * @method void render(string $template, array $data = [])
 * @method void redirect(string $url)
 */
abstract class BaseController
{
    /** @var Engine */
    protected Engine $app;

    /**
     * Constructor
     */
    public function __construct(Engine $app)
    {
        $this->app = $app;
    }

    /**
     * Call method to create a shortcut to the $app property
     * 
     * @param string $name The method name
     * @param array $arguments The method arguments
     * 
     * @return mixed
     */
    public function __call(string $name, array $arguments)
    {
        return $this->app->$name(...$arguments);
    }

}

That __call() method is a little helpful shortcut so you don't have to do $this->app->something() in your controllers, you can instead do $this->something() and it "forwards" it to $this->app->something(). There's also reference to a Session class in there that we'll talk about in juuuuuust a bit. Now we can clean up the controller code a little bit. Here's the HomeController.php with the cleaned up code.

<?php

declare(strict_types=1);

namespace app\controllers;

class HomeController extends BaseController
{
    /**
     * Index
     * 
     * @return void
     */
    public function index(): void
    {
        $this->render('home.latte', [ 'page_title' => 'Home' ]);
    }
}

Cleaner right? You can apply this same set of changes to the PostController and CommentController.

Route Cleanup

You may have noticed we hard coded the routes in our little app. We can use route aliases to change that behavior so more flexible in the future (especially with such a new blog, anything can change at this point!)

So let's add an alias to our home route:

$router->get('/', \app\controllers\HomeController::class . '->index')->setAlias('home');

Then we have a couple options to generate the URLs from the alias. In some controller methods you'll notice there is a $this->app->redirect('/blog'); statement. To generate the URL from the alias you could do the following instead:

// after we setup the 'blog' alias
$url = $this->app->getUrl('blog');
$this->app->redirect($url);

If you need to add a method in your Latte code to generate the URL for you, we could change how Latte is setup.

$Latte = new \Latte\Engine;
$Latte->setTempDirectory(__DIR__ . '/../cache/');

// This adds a new function in our Latte template files
// that allows us to generate a URL from an alias.
$Latte->addFunction('route', function(string $alias, array $params = []) use ($app) {
    return $app->getUrl($alias, $params);
});
$app->map('render', function(string $templatePath, array $data = [], ?string $block = null) use ($app, $Latte) {
    $templatePath = __DIR__ . '/../views/'. $templatePath;
    $Latte->render($templatePath, $data, $block);
});

And now that you have the code in place, when you're in your template files, you can do something like this:

<!-- this was /blog/{$post->id}/edit -->
<a class="pseudo button" href="{route('blog_edit', [ 'id' => $post->id ])}">Update</a>

Why do we do this when it seems like it takes longer to create the url?

Well some software platforms need to adjust their URLs (because marketing or product said so). Let's say you've hard coded everything so that the blog page is the /blog URL and marketing says they want another blog page, but the current blog page URL they want as a different page for a different market segment. In this case, let's say they want it to be changed from /blog to /blog-america. If you used aliases, all you would have to do is change the route URL in one spot (the routes.php file), and everywhere around your codebase it will update to the new URL. Pretty nifty right? If you want to have some fun, now that you've added an alias for /blog/@id/edit, why don't you change the URL part to /blog/@id/edit-me-i-dare-you. Now when you refresh the page, you'll see that because of the ->getUrl('blog_edit') code you're using, your URL's just updated themselves and when you click on the new URL is just works! Sweet!

Added bonus, you'll notice with the comment aliases we use that we only do this:

<a class="pseudo button" href="{route('comment_destroy', [ 'comment_id' => $comment->id ])}">Delete</a>

We should need to also specify @id right cause the route is $router->get('/@id/comment/@comment_id/delete', /* ... */);? Well, when getUrl() is called, it will take a peek at your current URL and if it sees that your current URL has an @id in it, it will automatically add that to the URL for you. So you don't have to worry about it!

Authentication with Middleware

You don't want anyone in the world to be able to update your blog right? So we'll need to implement a simple login mechanism to make sure that only logged in people can add to or update the blog. If you're remembering from up above, we need to add a route, either a new controller and a method or a method in an existing controller, and a new HTML file. Let's create the routes we'll need first:

// Blog
$router->group('/blog', function(Router $router) {

    // Login
    $router->get('/login', \app\controllers\LoginController::class . '->index')->setAlias('login');
    $router->post('/login', \app\controllers\LoginController::class . '->authenticate')->setAlias('login_authenticate');
    $router->get('/logout', \app\controllers\LogoutController::class . '->index')->setAlias('logout');

    // Posts
    // your post routes

});

Now let's create new controllers with runway:

php runway make:controller Login
php runway make:controller Logout

And you can copy the code below into your LoginController.php:

<?php

declare(strict_types=1);

namespace app\controllers;

class LoginController extends BaseController
{
    /**
     * Index
     * 
     * @return void
     */
    public function index(): void
    {
        $this->render('login/index.latte', [ 'page_title' => 'Login' ]);
    }

    /**
     * Authenticate
     * 
     * @return void
     */
    public function authenticate(): void
    {
        $postData = $this->request()->data;
        if($postData->username === 'admin' && $postData->password === 'password') {
            $this->session()->set('user', $postData->username);
            $this->session()->commit();
            $this->redirect($this->getUrl('blog'));
            exit;
        }
        $this->redirect($this->getUrl('login'));
    }
}

And copy the below code for your LogoutController.php:

<?php

declare(strict_types=1);

namespace app\controllers;

class LogoutController extends BaseController
{
    /**
     * Index
     * 
     * @return void
     */
    public function index(): void
    {
        $this->session()->destroy();
        $this->redirect($this->getUrl('blog'));
    }
}

Well wait a minute here, the controller is now calling a session() method. We'll need to register a new service in our services.php file to handle sessions. Thankfully there's a great session handler that we can use! First we'll need to install it with composer:

composer require ghostff/session

Now we can add the session service to our services.php file:

// Session Handler
$app->register('session', \Ghostff\Session\Session::class);

Do you see that $this->session->commit(); line in the controller? This is a very intentional design decision by the library author for a very good reason. Long story short, in PHP there is such a thing as session_write_close() which writes the session data and closes the session.

This is important because if you have a lot of AJAX requests, you don't want to lock the session file for the entire time the request is being processed. That might sound pointless to you, but what if one of your ajax requests (or page loads) is running a very large report that might take 10-20 seconds to run? During that time you will not be able to make another request on the same site because the session in locked. Yikes!

The commit() method is a way to write the session data and close the session. If you don't call commit() the session will actually never be written to, which can be annoying, but what's more annoying is having long requests hang (like a report running) that causes your entire app to appear to freeze up!

Now we can create the HTML file for the login page. Create a new file at app/views/login/index.latte and put in the following code:

{extends '../layout.latte'}

{block content}
<h1>Login</h1>
<form action="{route('login_authenticate')}" method="post">
    <p>Login as whoever! And the password is always "password" (no quotes)</p>
    <label for="username">Username:</label>
    <input type="text" name="username" id="username" required>
    <label for="password">Password:</label>
    <input type="password" name="password" id="password" required>

    <button type="submit">Login</button>
</form>
{/block}

Lastly, we just need a link to our new login page (and a logout one while we're at it)! Let's add a link to the app/views/blog/index.latte file just after the {/foreach} loop:

<p><a href="{route('login')}">Login</a> - <a href="{route('logout')}">Logout</a></p>

Umm...wait, so we can login as anyone?! That's not very secure and you're right! We're only doing this for demonstration purposes. Of course we would want to have a system where we use password_hash('my super cool password', PASSWORD_BCRYPT) to hash the password and then store that in the database. But that's a topic for another blog post!

So we now have a login system in place. But what if we want to make sure that only logged in users can access the blog? We can use middleware to help us with that! A middleware is a piece of code that runs before or after a route. We can use middleware to check if a user is logged in and if they are not, we can redirect them to the login page. Let's create a new file at app/middlewares/LoginMiddleware.php:

<?php

declare(strict_types=1);

namespace app\middlewares;

use flight\Engine;

class LoginMiddleware {

    /** @var Engine */
    protected Engine $app;

    public function __construct(Engine $app)
    {
        $this->app = $app;
    }

    public function before(): void
    {   
        if ($this->app->session()->exist('user') === false) {
            $this->app->redirect($this->app->getUrl('login'));
        }
    }
}

Now that we are able to use sessions, we actually can inject them as globals into our templates. Let's go to the services.php file and change our render method to the following:

$app->map('render', function(string $templatePath, array $data = [], ?string $block = null) use ($app, $Latte) {
    $templatePath = __DIR__ . '/../views/'. $templatePath;
    // Add the username that's available in every template.
    $data = [
        'username' => $app->session()->getOrDefault('user', '')
    ] + $data;
    $Latte->render($templatePath, $data, $block);
});

Note: One thing that's important when injecting a variable at this point is that it becomes "global". Global variables in general are bad if they are not injected properly. Don't inject the whole session, but instead inject the specific variable you need. In this case, we only need the username. Globals can be bad, you've been warned!

Now we can run checks in our templates to see if the user is logged in and if we want to show certain elements or not. For example, in the app/views/blog/index.latte file, we can add the following code:

{if $username}
<p><a class="button" href="{route('blog_create')}">Create a new post</a></p>
{/if}

If the user isn't logged in, that button won't show! Pretty cool eh?

But wait, there's more!

So, wait, remember that handy dandy debug bar called Tracy? There's an extension for it that we can take advantage of to inspect our session variables. Let's go to the config.php file and change a line of code:

(new TracyExtensionLoader($app));
// change it to...
(new TracyExtensionLoader($app, [ 'session_data' => (new \Ghostff\Session\Session)->getAll() ]));

While we're at it, you get a free bonus of a built in Latte extension (cause you've read all the way to down here!). Go to your services.php file and add this line after the $Latte->setTempDirectory(__DIR__ . '/../cache/'); line:

// PHP 8+
$Latte->addExtension(new Latte\Bridges\Tracy\TracyExtension);
// PHP 7.4
Latte\Bridges\Tracy\LattePanel::initialize($Latte);

Here's some pictures of the various Tracy Extensions:

See how helpful it is to see the query that's run, and to see where the query was ran so you can trace it down???

Here's Latte to help you know the template you're using.

And here's the session data. Obviously if we had more session data this would be more useful.

Permissions

Now that we can see that we are logged in or not, maybe there are more fine grained permissions that we need to look at. For instance, can only certain people after logging in edit a blog post? Can certain people delete?

Now we can create user roles for your blog such as user (anyone can view the blog and make a comment), editor (only you can create/edit a post) and admin (you can create, update and delete a post/comment).

Flight has a package for permissions that we can use. Let's install it with composer:

composer require flightphp/permissions

Now we can add the permissions service to our services.php file:

// Permissions
$currentRole = $app->session()->getOrDefault('role', 'guest');
$app->register('permission', \flight\Permission::class, [ $currentRole ]);
$permission = $app->permission();
$permission->defineRule('post', function(string $currentRole) {
    if($currentRole === 'admin') {
        $permissions = ['create', 'read', 'update', 'delete'];
    } else if($currentRole === 'editor') {
        $permissions = ['create', 'read', 'update'];
    } else {
        $permissions = ['read'];
    }
    return $permissions;
});
$permission->defineRule('comment', function(string $currentRole) {
    if($currentRole === 'admin') {
        $permissions = ['create', 'read', 'update', 'delete'];
    } else if($currentRole === 'editor') {
        $permissions = ['create', 'read', 'update'];
    } else {
        $permissions = ['read'];
    }
    return $permissions;
});

Also let's change some of the LoginController->authenticate() method to add the user role to the session:

if($postData->password === 'password') {
    $this->session()->set('user', $postData->username);

    // Sets the current user role
    if($postData->username === 'admin') {
        $this->session()->set('role', 'admin');
    } else if($postData->username === 'editor') {
        $this->session()->set('role', 'editor');
    } else {
        $this->session()->set('role', 'user');
    }
    $this->session()->commit();
    $this->redirect($this->getUrl('blog'));
    exit;
}

Note: This is a very simple example of how you can set roles. In a real world application, you would have a database table (or something) that would store the user roles and you would query the database to get the user role. For illustrative purposes, your user role in our blog application will be determined by the username you use to login.

We can also create another function in Latte to help use utilize these permissions. Let's go to the services.php file and add another function after the route function:

$Latte->addFunction('permission', function(string $permission, ...$args) use ($app) {
    return $app->permission()->has($permission, ...$args);
});

Now we can use the permission function in our templates. Let's go to the app/views/blog/index.latte file and add a permission to the create button to check if you really can create a blog post or not:

{if $username && permission('post.create')}
<p><a class="button" href="{route('blog_create')}">Create a new post</a></p>
{/if}

You can now add additional permissions checks for reading, updating, and deleting posts. Go ahead to the login page and login as admin and password. Then try it with user and password and notice the differences!

Active Record Improvements

The active record class is relatively simple, but it has a few tricks up its sleeve. For instance we can have certain events trigger behaviors for us automatically (like adding an updated_at timestamp when we update a record). We also can connect records together by defining relationships in the active record class. Let's go to the app/records/PostRecord.php file and you can paste in the following code:

<?php

declare(strict_types=1);

namespace app\records;

use app\records\CommentRecord;
use Flight;

/**
 * ActiveRecord class for the posts table.
 * @link https://docs.flightphp.com/awesome-plugins/active-record
 *
 * @property int $id
 * @property string $title
 * @property string $content
 * @property string $username
 * @property string $created_at
 * @property string $updated_at
 * @method CommentRecord[] comments()
 */
class PostRecord extends \flight\ActiveRecord
{
    /**
     * @var array $relations Set the relationships for the model
     *   https://docs.flightphp.com/awesome-plugins/active-record#relationships
     */
    protected array $relations = [
        'comments' => [self::HAS_MANY, CommentRecord::class, 'post_id'],
    ];

    /**
     * Constructor
     * @param mixed $databaseConnection The connection to the database
     */
    public function __construct($databaseConnection = null)
    {
        $databaseConnection = $databaseConnection ?? Flight::db();
        parent::__construct($databaseConnection, 'posts');
    }

    public function beforeInsert(): void
    {
        $this->created_at = gmdate('Y-m-d H:i:s');
        $this->updated_at = null;
    }

    public function beforeUpdate(): void
    {
        $this->updated_at = gmdate('Y-m-d H:i:s');
    }
}

So let's talk about what's different.

Relationships

We've added a protected array $relations property to the class. This is a way to define relationships between records. In this case, we've defined a comments relationship. This is a HAS_MANY relationship, meaning that a post can have many comments. The CommentRecord::class is the class that represents the comments table, and the post_id is the foreign key that links the comments to the posts.

What this will allow us to do is in our code we can save a lot of headache but just doing $post->comments() and it will return all the comments for that post. For example, in the PostController we can change the show method to the following:

/**
 * Show
 *
 * @param int $id The ID of the post
 * @return void
 */
public function show(int $id): void
{
    $PostRecord = new PostRecord($this->db());
    $post = $PostRecord->find($id);
    // Don't need these as it now will "just work" with the relationship we've defined
    // $CommentRecord = new CommentRecord($this->db());
    // $post->comments = $CommentRecord->eq('post_id', $post->id)->findAll();
    $this->render('posts/show.latte', [ 'page_title' => $post->title, 'post' => $post]);
}

Super cool right? You'll also notice the @method CommentRecord[] comments() in the docblock. This is a way to tell your IDE that the comments() method will return an array of CommentRecord objects giving you a ton of help with autocompletion and type hinting.

Note: This is a very simple example of a relationship. In a real world application, you would have more complex relationships such as HAS_ONE, BELONGS_TO, and MANY_MANY. You can read more about relationships here.

Performance Note: Relationships are great for single records, or for small collections of records. Just remember the fact that everytime you do ->comments() it will run a query to get the comments. If you have say a query to pull back all the posts for your blog which are say 10 posts, and then put that in a foreach loop, you will have 1 query for your posts, and then 1 query for each of your 10 posts to get the comments. This is called the N+1 problem. It's not a bad problem in a small codebase, but in a large codebase it can be a big problem!

Events

Instead of coding in the date that needs to be assigned to every record, we can actually take care of that automatically through events! Above you'll notice there is now a beforeInsert and beforeUpdate method. These are example event methods that are called before the record is inserted or updated. This is a great way to add some default values to your records without having to remember to do it every time. So in the PostController we can remove the lines that set the created_at and updated_at fields like below (cause they'll now be filled in automatically):

$PostRecord = new PostRecord($this->db());
$PostRecord->find($id);
$PostRecord->title = $postData->title;
$PostRecord->content = $postData->content;
// $PostRecord->updated_at = gmdate('Y-m-d H:i:s');
$PostRecord->save();

One other thing that's really helpful with events is that you can automatically hash/encrypt/encode values and decrypt/decode values when you pull out records automatically. For instance in a UserRecord->beforeInsert() method you could has the password before it's inserted into the database:

public function beforeInsert(): void {
    $this->password = password_hash($this->password, PASSWORD_BCRYPT);
}

Auto Create the Database Connection

You'll notice that we've changed the constructor to accept no argument and that if $databaseConnection is null it will automatically use the global Flight::db() connection. This is a nice little feature that allows you to not have to pass in the database connection every time you create a new record and reduces precious keystrokes on your fingies.

public function __construct($databaseConnection = null)
{
    $databaseConnection = $databaseConnection ?? Flight::db();
    parent::__construct($databaseConnection, 'posts');
}

So now you can just do $PostRecord = new PostRecord(); and it will automatically use the global database connection. But when unit testing you can inject a mock connection to test your active record class.

Reactify/Vueify/Angularify

We totally could have put some JavaScript framework in this project and changed our routes to be ->put() or ->delete() instead. This tutorial was just to help you grasp a basic understanding of how the framework works. Go ahead and throw some fancy JS into it in your own blog post!

Conclusion

This was a longer couple of posts, but you made it! Hopefully this illustrated some of the amazing things that Flight can do for you. It's a very lightweight framework that can be extended to do a lot of things. It's not as feature rich as Laravel or Symfony, but it's not trying to be. It's trying to be a simple framework that you can use to understand why you need a framework in the first place.

Do yourself a favor and smash that subscribe button and pat yourself on the back cause you're worth it! You work hard at reading long blog posts about creating blog....posts. :D Leave a comment with any questions or catch us in our chat room

Building a Simple Blog with Flight - Part 1

n0nag0n — Thu, 04 Jul 2024 05:07:59 +0000

Hey everyone! I figured it was time to showcase some of the new features that have been added to the Flight Framework for PHP. Earlier this year the original creator of Flight Mike Cao graciously offered to transfer ownership of mikecao/flight over to a new Flight PHP organization. Since it's been moved we've added features like middleware, route grouping, DIC, and other features. This post will be a little longer, but it's just because I've included a lot of code examples so you can have the right context into how your blog will get built.

First off, let's just get this out of the way. Flight is meant to be a simple framework with a few bells and whistles. It will not compete with Laravel or Symfony or Yii or Cake or [fill in the blank]. This framework is really built towards simple to medium size projects. It also caters to those who don't like "magic" in their code that's hard to understand or train to. It's geared more towards developers who are just starting to branch into frameworks instead of raw PHP with a lot of random include statements.

tl;dr

Lots of cool features, nice simple implementation, blah blah blah here's the code. Go to part 2 for the cool stuff!

Installation

Let's use Composer to get this party started.

composer create-project flightphp/skeleton blog/
cd blog/

Configure your New Project

First thing to do is to go to the app/config/config.php file where we can put any config like API keys, database credentials, and other important credentials for our app. For this blog, we'll uncomment the line with file_path for our SQLite database path:

return [
    'database' => [
        // 'host' => 'localhost',
        // 'dbname' => 'dbname',
        // 'user' => 'user',
        // 'password' => 'password'
        'file_path' => __DIR__ . $ds . '..' . $ds . 'database.sqlite'
    ],
];

Create the Blog Database

Flight now comes with a command line utility called runway. This allows you to create custom commands for a plugin for Flight, or even for your own project.

As part of the skeleton, it comes with a SampleDatabaseCommand that will give us a starting point with this blog project we are creating.

Run the below command and it should populate your database for you!

php runway init:sample-db

Next we'll open up the app/config/services.php file and uncomment the line for SQLite.

// see how the $config variable references the config line we uncommented earlier?
$dsn = 'sqlite:' . $config['database']['file_path'];

Just to make sure we've got everything setup correctly, run composer start and then go to http://localhost:8000/ in your browser. You should see the following screen:

You'll also notice in the corner you have a handy debug toolbar with some custom Flight panels to help you understand what's going on in your application. If you hover over the various items in the toolbar, you'll see a variety of hovers that you can click on to keep sticky on the page (more on that later).

Building the HTML Templates

Flight does come with a very basic HTML templating solution already in the framework. This is just fine for very simple sites or just to return a simple piece of HTML. It is recommended to use another templating platform such as Latte, Twig, or Blade. In this tutorial, we're going to use Latte because it is awesome and has no dependencies (you'll notice in Flight we do not like unnecessary dependencies)!

Go ahead and install Latte

composer require latte/latte

Add this to your services.php

$Latte = new \Latte\Engine;
$Latte->setTempDirectory(__DIR__ . '/../cache/');

// This is fun feature of Flight. You can remap some built in functions with the framework
// to your liking. In this case, we're remapping the Flight::render() method.
$app->map('render', function(string $templatePath, array $data = [], ?string $block = null) use ($app, $Latte) {
    $templatePath = __DIR__ . '/../views/'. $templatePath;
    $Latte->render($templatePath, $data, $block);
});

Now that we have a templating engine in place, we can create a base HTML file. Let's create a layout.latte file:

<!doctype html>
<html lang="en">
    <head>
        <!-- Picnic.css is a CSS framework that works out of the box with little configuration -->
        <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/picnic">
        <meta charset="utf-8">
        <meta name="viewport" content="width=device-width, initial-scale=1">
        <title>{$page_title ? $page_title.' - '}Blog Built with Flight!</title>
    </head>
    <body style="padding: 15px;">
        {block content}{/block}
    </body>
</html>

Active Record Database Class

Flight has a plugin for interacting with a database called Flight Active Record. This plugin helps you not write as much raw SQL in your apps (although sometimes it is more efficient to write a raw SQL query instead of forcing an active record/ORM/mapper to run it for you). Basically the active record extension helps you interact with rows within tables in your database: one row in a database can be mapped to an object in PHP (with autocomplete for the columns) saving time and sanity. Let's get it installed in our project.

composer require flightphp/active-record

Now you can use runway to create your active record classes automatically for you and it will create your properties as comments automatically (for autocomplete)!

First let's create the posts class. The first time you run this, it needs to setup the connection for the database.

$ php runway make:record posts
Database configuration not found. Please provide the following details:
Driver (mysql/pgsql/sqlite): sqlite
Database file path [database.sqlite]: app/database.sqlite
Username (for no username, press enter) []: 
Password (for no password, press enter) []: 
Writing database configuration to .runway-config.json
Creating directory app/records
Active Record successfully created at app/records/PostRecord.php

Now we'll create the comments record class:

$ php runway make:record comments

It's Time for your First Page!

Flight uses the MVC pattern. In order to create a new page you need to define a route in your routes.php file, create a new method in a controller, and then create the HTML file that the browser will serve. You can use runway to help you get started with a new controller class:

php runway make:controller Home

And you should see something similar to the following:

$ php runway make:controller Home
Controller successfully created at app/controllers/HomeController.php

If you go to app/controllers/HomeController.php go ahead and add this new method to your HomeController:

/**
 * Index
 * 
 * @return void
 */
public function index(): void
{
    $this->app->render('home.latte', [ 'page_title' => 'Home' ]);
}

And create a new file in app/views/home.latte and put in this code:

{extends 'layout.latte'}

{block content}
<h1>My Home Page</h1>
<p><a href="/blog">View My Blog!</a></p>
{/block}

Finally let's change up the routes to the routes.php file. Go ahead and remove any code in the routes file that begins with $router-> and add a new route for your home router:

$router->get('/', \app\controllers\HomeController::class . '->index');

Make sure you run composer start so that your development server is up. If you go to http://localhost:8000/ in your browser, you should see something like this!

Now we're cookin'!

Adding Routes for the Blog

Let's go ahead and add all the methods in your controller, routes, and html files. Let's start with adding the routes in your routes.php file:

// Blog
$router->group('/blog', function(Router $router) {

    // Posts
    $router->get('', \app\controllers\PostController::class . '->index');
    $router->get('/create', \app\controllers\PostController::class . '->create');
    $router->post('', \app\controllers\PostController::class . '->store');
    $router->get('/@id', \app\controllers\PostController::class . '->show');
    $router->get('/@id/edit', \app\controllers\PostController::class . '->edit');
    $router->post('/@id/edit', \app\controllers\PostController::class . '->update');
    $router->get('/@id/delete', \app\controllers\PostController::class . '->destroy');
});

So you'll notice we use a group() method here to group all the routes together that start with /blog. We could actually rewrite the routes like the following with the group() method and the same thing would happen:

// Posts
$router->get('/blog', \app\controllers\PostController::class . '->index');
$router->get('/blog/create', \app\controllers\PostController::class . '->create');

With the controller, first let's create an empty controller with runway:

php runway make:controller Post

You can copy the code below for your PostController.php:

<?php

declare(strict_types=1);

namespace app\controllers;

use app\records\CommentRecord;
use app\records\PostRecord;
use flight\Engine;

class PostController
{
    /** @var Engine */
    protected Engine $app;

    /**
     * Constructor
     */
    public function __construct(Engine $app)
    {
        $this->app = $app;
    }

    /**
     * Index
     *
     * @return void
     */
    public function index(): void
    {
        $PostRecord = new PostRecord($this->app->db());
        $posts = $PostRecord->order('id DESC')->findAll();
        $CommentRecord = new CommentRecord($this->app->db());
        foreach($posts as &$post) {
            $post->comments = $CommentRecord->eq('post_id', $post->id)->findAll();
        }
        $this->app->render('posts/index.latte', [ 'page_title' => 'Blog', 'posts' => $posts]);
    }

    /**
     * Create
     *
     * @return void
     */
    public function create(): void
    {
        $this->app->render('posts/create.latte', [ 'page_title' => 'Create Post']);
    }

    /**
     * Store
     *
     * @return void
     */
    public function store(): void
    {
        $postData = $this->app->request()->data;
        $PostRecord = new PostRecord($this->app->db());
        $PostRecord->title = $postData->title;
        $PostRecord->content = $postData->content;
        $PostRecord->username = $postData->username;
        $PostRecord->created_at = gmdate('Y-m-d H:i:s');
        $PostRecord->updated_at = null;
        $PostRecord->save();
        $this->app->redirect('/blog');
    }

    /**
     * Show
     *
     * @param int $id The ID of the post
     * @return void
     */
    public function show(int $id): void
    {
        $PostRecord = new PostRecord($this->app->db());
        $post = $PostRecord->find($id);
        $CommentRecord = new CommentRecord($this->app->db());
        $post->comments = $CommentRecord->eq('post_id', $post->id)->findAll();
        $this->app->render('posts/show.latte', [ 'page_title' => $post->title, 'post' => $post]);
    }

    /**
     * Edit
     *
     * @param int $id The ID of the post
     * @return void
     */
    public function edit(int $id): void
    {
        $PostRecord = new PostRecord($this->app->db());
        $post = $PostRecord->find($id);
        $this->app->render('posts/edit.latte', [ 'page_title' => 'Update Post', 'post' => $post]);
    }

    /**
     * Update
     *
     * @param int $id The ID of the post
     * @return void
     */
    public function update(int $id): void
    {
        $postData = $this->app->request()->data;
        $PostRecord = new PostRecord($this->app->db());
        $PostRecord->find($id);
        $PostRecord->title = $postData->title;
        $PostRecord->content = $postData->content;
        $PostRecord->username = $postData->username;
        $PostRecord->updated_at = gmdate('Y-m-d H:i:s');
        $PostRecord->save();
        $this->app->redirect('/blog');
    }

    /**
     * Destroy
     *
     * @param int $id The ID of the post
     * @return void
     */
    public function destroy(int $id): void
    {
        $PostRecord = new PostRecord($this->app->db());
        $post = $PostRecord->find($id);
        $post->delete();
        $this->app->redirect('/blog');
    }
}

Let's kill some time and talk about a few things that are going on in the controller.

First off we are now using our new active record classes:

$PostRecord = new PostRecord($this->app->db());
$posts = $PostRecord->order('id DESC')->findAll();

We are injecting the database we setup in the services.php file above with $this->app->db();. Technically we could also just use Flight::db() as this points to the global $app variable.

Active Record classes are really helpful to simplify interactions with a database. We could rewrite the above in the following code:

$posts = $this->app->db()->fetchAll("SELECT * FROM posts ORDER BY id DESC");

This might not be the best example of how helpful an active record could be. But in part 2 I'll show you some hidden gems inside these classes that make it so much better than writing raw SQL.

Now let's talk HTML files. Here are the files we'll need for the post routes:

app/views/posts/index.latte

{extends '../layout.latte'}

{block content}

<h1>My Amazing Blog</h1>
<p>Welcome to my blog!</p>
<p><a class="button" href="/blog/create">Create a new post</a></p>
{foreach $posts as $post}
    {first}
    <h2>Recent Posts</h2>
    {/first}
    <hr>
    <h3><a href="/blog/{$post->id}">{$post->title}</a></h3>
    <p><small>By: {$post->username} on {$post->created_at|date:'d.m.Y G:i a'}</small></p>
    <p>Comments: {count($post->comments)}
    <p>{$post->content|truncate:100}</p>
    <hr>
    <a class="pseudo button" href="/blog/{$post->id}/edit">Update</a> - <a class="pseudo button" href="/blog/{$post->id}/delete">Delete</a>
{/foreach}

{/block}

app/views/posts/show.latte

{extends '../layout.latte'}

{block content}
<a href="/blog">&lt; Back to blog</a>
<h1>{$post->title}</h1>
<p>Created by: {$post->username} on {$post->created_at|date:'d.m.Y G:i a'}.</p>
<div>
    {$post->content|breakLines}
</div>
<p n:if="$post->update_at">Last update: {$post->update_at|date:'d.m.Y G:i a'}.</p>

<h2>Comments</h2>
{foreach $post->comments as $comment}
<div>
    <p>{$comment->username} on {$comment->created_at|date:'d.m.Y G:i a'}.</p>
    <div>
        {$comment->content|breakLines}
    </div>
    <hr>
    <a class="pseudo button" href="/blog/{$post->id}/comment/{$comment->id}/delete">Delete</a>
</div>
{else}
<p>No comments yet.</p>
{/foreach}

<h2>Add comment</h2>
<form action="/blog/{$post->id}/comment" method="post">
    <div>
        <label for="username">Username:</label>
        <input name="username" id="username" placeholder="Username" required />
    </div>
    <div>
        <label for="content">Comment:</label>
        <textarea name="content" id="content" placeholder="Comment" required></textarea>
    </div>
    <div>
        <button type="submit">Add Comment</button>
    </div>
</form>
{/block}

app/views/posts/create.latte

{extends '../layout.latte'}

{block content}
<h1>Create a Post</h1>
<form action="/blog" method="post">
    <label><input type="text" name="title" placeholder="Title" required></label>
    <label><textarea name="content" placeholder="Content" required></textarea></label>
    <label><input type="text" name="username" placeholder="Username" required></label>

    <button type="submit">Create</button>
</form>
{/block}

app/views/posts/edit.latte

{extends '../layout.latte'}

{block content}
<h1>Update a Post</h1>
<form action="/blog/{$post->id}/edit" method="post">
    <label for="title">Title</label>
    <input type="text" name="title" placeholder="Title" value="{$post->title}" required>

    <label for="content">Content</label>
    <label><textarea name="content" placeholder="Content" required>{$post->content}</textarea>

    <label for="username">Username</label>
    <label><input type="text" name="username" placeholder="Username" value="{$post->username}" required>

    <button type="submit">Update</button>
</form>
{/block}

Create a new post

Now that we've got all the pieces in place, you should be able to load up your blog page, create a new post, see a post, and delete a post. You may have noticed we've included a comment form but the form doesn't actually work. We can fix that real quick! Let's create a controller with runway:

php runway make:controller Comment

Now you can make the CommentController.php look like the following:

<?php

declare(strict_types=1);

namespace app\controllers;

use app\records\CommentRecord;
use flight\Engine;

class CommentController
{
    /** @var Engine */
    protected Engine $app;

    /**
     * Constructor
     */
    public function __construct(Engine $app)
    {
        $this->app = $app;
    }

    /**
     * Store
     * 
     * @param int $id The post ID
     * 
     * @return void
     */
    public function store(int $id): void
    {
        $postData = $this->app->request()->data;
        $CommentRecord = new CommentRecord($this->app->db());
        $CommentRecord->post_id = $id;
        $CommentRecord->username = $postData->username;
        $CommentRecord->content = $postData->content;
        $CommentRecord->created_at = gmdate('Y-m-d H:i:s');
        $CommentRecord->updated_at = null;
        $CommentRecord->save();
        $this->app->redirect('/blog/' . $id);
    }

    /**
     * Destroy
     * 
     * @param int $id The post ID
     * @param int $comment_id The comment ID
     * 
     * @return void
     */
    public function destroy(int $id, int $comment_id): void
    {
        $CommentRecord = new CommentRecord($this->app->db());
        $CommentRecord->find($comment_id);
        $CommentRecord->delete();
        $this->app->redirect('/blog/' . $id);
    }

}

Now let's add a couple other routes in the group chunk of code in routes.php

// Blog
$router->group('/blog', function(Router $router) {

    // Posts

    // post routes...

    // Comments
    $router->post('/@id/comment', \app\controllers\CommentController::class . '->store');
    $router->get('/@id/comment/@comment_id/delete', \app\controllers\CommentController::class . '->destroy');
});

Conclusion (sort of)

With these two additions to the code, you have a fully functioning blog built with Flight! This got the job done and you now have a blog, but the code is somewhat clunky and could be improved to have some pretty nifty features like middleware, permissions, and writing less code! Hop over to part 2

Go ahead and leave any questions in comments below or join us in the chatroom!

If you want to see the final product with all the improvements here's the code!

Creating a RESTful API with Flight Framework

n0nag0n — Sat, 15 Jun 2024 20:38:03 +0000

In this article, we'll walk through building a RESTful API using the Flight framework, which is a simple yet powerful PHP micro-framework. Flight aims to be simple to understand what is going on with your application and leave you in control without too much "magic" happening. We'll cover the basics of setting up the framework, creating a user resource in a SQLite database, and implementing a simple authentication middleware.

Getting Started with Flight

First, let's set up Flight and create our project. You can download Flight from its GitHub repository or installed via composer. Composer is generally the way to go.

Installation

You can install Flight via Composer. Create a new directory for your project and run the following command:

composer require flightphp/core

Setting Up Your Project

Here is the example directory structure for your project:

project-root/
├── public/
│   └── index.php
├── config/
│   └── config.php
├── middleware/
│   └── AuthMiddleware.php
├── vendor/
└── composer.json

Create an index.php file in your public directory. This file will serve as the entry point for your application.

<?php
require __DIR__.'/../vendor/autoload.php';

Flight::route('/', function(){
    echo 'Hello, world!';
});

Flight::start();

Open up your terminal application and type php -S localhost:8080 -t public/ and navigate to http://localhost:8080 to see the "Hello, world!" message. If you get an error message about a port already being used, go ahead and try another port like 8081.

Creating the User Resource

Now, let's create a user resource with CRUD operations. We'll use SQLite for the database for the simplicity of this tutorial, but you can use any database of your choice.

Database Connection

Create a config.php file to store your database credentials:

<?php
// config.php
return [
    'database_path' => __DIR__.'/../flight_app.sqlite',
];

CRUD Operations

In your index.php file, include the database connection and define CRUD operations for the user resource.

<?php
require __DIR__.'/../vendor/autoload.php';
$config = require __DIR__.'/../config/config.php';

// This is where you can register a database connection so you can use it in any of your routes below
Flight::register('db', \flight\database\PdoWrapper::class, [ 'sqlite:'.$config['database_path'] ], function($db){
    $db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
    $db->setAttribute(PDO::ATTR_DEFAULT_FETCH_MODE, PDO::FETCH_ASSOC);
});

// This will create the database and the users table if it doesn't exist already
if(file_exists($config['database_path']) === false) {
    $db = Flight::db();
    $db->runQuery("CREATE TABLE users (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT NOT NULL, email TEXT NOT NULL UNIQUE, password TEXT NOT NULL)");
}

// A group helps group together similar routes for convenience
Flight::group('/users', function(\flight\net\Router $router) {

    // Get all users
    $router->get('', function(){
        $db = Flight::db();
        $users = $db->fetchAll("SELECT * FROM users");
        Flight::json($users);
    });

    // Get user by id
    $router->get('/@id', function($id){
        $db = Flight::db();
        $user = $db->fetchRow("SELECT * FROM users WHERE id = :id", [ ':id' => $id ]);
        if (!empty($user['id'])) {
            Flight::json($user);
        } else {
            Flight::jsonHalt([ 'message' => 'User not found' ], 404);
        }
    });

    // Create new user
    $router->post('', function(){
        $data = Flight::request()->data;
        $db = Flight::db();
        $result = $db->runQuery("INSERT INTO users (name, email, password) VALUES (:name, :email, :password)", [ 
            ':name' => $data['name'], 
            ':email' => $data['email'], 
            ':password' => password_hash($data['password'], PASSWORD_BCRYPT) 
        ]);
        Flight::json([ 'id' => $db->lastInsertId() ], 201);
    });

    // Update user
    $router->put('/@id', function($id){
        $data = Flight::request()->data->getData();
        $db = Flight::db();
        $result = $db->runQuery("UPDATE users SET name = :name, email = :email, password = :password WHERE id = :id", [
            ':id' => $id,
            ':name' => $data['name'],
            ':email' => $data['email'],
            ':password' => password_hash($data['password'], PASSWORD_BCRYPT)
        ]);
        Flight::json([ 'message' => 'User updated successfully' ]);
    });

    // Delete user
    $router->delete('/@id', function($id){
        $db = Flight::db();
        $stmt = $db->runQuery("DELETE FROM users WHERE id = :id", [ ':id' => $id ]);
        Flight::json([ 'message' => 'User deleted successfully' ]);
    });

});

Flight::start();

Simple Authentication Middleware

Next, let's implement a simple authentication middleware to protect our API routes.

Create a new file called AuthMiddleware.php:

<?php
// AuthMiddleware.php

class AuthMiddleware {

    public function before() {
        $headers = Flight::request()->getHeaders();
        if (isset($headers['Authorization']) === true) {
            $token = $headers['Authorization'];
            // Normally, you would validate the token here. For simplicity, we'll just check if it's "secret"
            if ($token == 'secret') {
                return true;
            }
        }
        Flight::jsonHalt([ 'message' => 'Unauthorized' ], 401);
    }

}

Include this middleware in your index.php file and protect your routes:

<?php
require __DIR__.'/../vendor/autoload.php';
$config = require __DIR__.'/../config/config.php';
require __DIR__.'/../middleware/AuthMiddleware.php';

// code to set up database connection (as shown above)

Flight::group('/users', function(\flight\net\Router $router) {

    // previously defined routes here

// This is where you put the middleware
}, [ new AuthMiddleware() ]);

// Repeat for other routes...

Example Usage

To test your API, you can use tools like Postman or cURL. Here’s an example using cURL to get all users:

Creating a User

curl -X POST -H "Authorization: secret" -d '{"name":"John Doe", "email":"john@example.com", "password":"password"}' http://localhost:8080/users

This will create a new user and return the user ID.

Getting All Users

curl -H "Authorization: secret" http://localhost:8080/users

This will return a JSON response with all the users in your database.

Getting a User by ID

Now that you have created a user, you can get the user by ID. You can get the ID from the response of the previous request.

curl -H "Authorization: secret" http://localhost:8080/users/1

Updating a User

You can update a user by sending a PUT request with the user ID and the updated data.

curl -X PUT -H "Authorization: secret" -d '{"name":"Jane Doe", "email":"jane@example.com", "password":"mynewpassword"}' http://localhost:8080/users/1

Deleting a User

You can delete a user by sending a DELETE request with the user ID.

curl -X DELETE -H "Authorization: secret" http://localhost:8080/users/1

Wrapping Up

Flight is a great choice for building simple and lightweight applications quickly. It offers the essential features needed for creating a RESTful API while being easy to learn and use. For many projects, Flight has plenty of features to help maintain the long term needs for your project. For more complex applications, you might consider using more robust frameworks like Laravel, CakePHP, or CodeIgniter, depending on your specific needs.

If you made it this far, here is the code used in this article.

Unveiling the Mystery: How the `DESCRIBE` Command Can Bring Down a Server

n0nag0n — Thu, 10 Aug 2023 01:29:09 +0000

Introduction

For the past eight months, our team has been on a detective mission. A mysterious graph started showing usage when some code went live, and it's been a rollercoaster ride trying to figure out the root cause. The culprit? The MySQL or MariaDB DESC, DESCRIBE, or EXPLAIN table commands.

The graph in Zabbix for temporary tables created per second began to fluctuate, and we were at a loss as to why. The situation escalated during a recent spike in usage, when our server became overloaded, and we started to notice a lot of DESCRIBE table commands in our process list.

This article uncovers the behavior of the DESCRIBE command and its link to temporary table creation, a discovery that illuminated our understanding and allowed us to resolve the issue.

What is the `DESCRIBE` Command?

The DESCRIBE command in MySQL or MariaDB is used to describe the structure of a table. It provides information about the columns, types, and other properties of the table. Here's a simple example:

DESCRIBE employees; -- also EXPLAIN employees; and DESC employees;

This would display the structure of the employees table, including column names, data types, etc.

+------------+--------------+------+-----+---------+-------+
| Field      | Type         | Null | Key | Default | Extra |
+------------+--------------+------+-----+---------+-------+
| id         | int          | NO   | PRI | NULL    |       |
| first_name | varchar(50)  | YES  |     | NULL    |       |
| last_name  | varchar(50)  | YES  |     | NULL    |       |
| salary     | decimal      | YES  |     | NULL    |       |
| hire_date  | date         | YES  |     | NULL    |       |
+------------+--------------+------+-----+---------+-------+

The Unexpected Behavior: Temporary Table Creation

What caught our attention was that in MariaDB, the description "Creating Temporary Table" appeared when running the DESCRIBE command. This was puzzling and led us to investigate further.

Why are Temporary Tables Created?

Temporary tables are often used to store intermediate results for complex queries. However, we didn't expect them to be linked to the DESCRIBE command. After digging into the MySQL/MariaDB documentation and source code, we realized that the DESCRIBE command indeed creates a temporary table to store and display the structure of the queried table.

The Impact on Performance

The frequent creation of temporary tables was taking a toll on our system. The server became overloaded, and the website's performance deteriorated.

Our code was using the DESC command to populate database mappers, and it seemed that the cache was not working properly. This resulted in an excessive number of DESC commands, leading to the unexpected creation of temporary tables.

How We Fixed the Issue

Our solution involved correcting the caching mechanism. Once the cache was functioning properly, the number of DESC commands plummeted, and the graph flatlined.

Here's a brief outline of the steps we took:

Analyzed the Caching Behavior: We found that the cache was not retaining the DESCRIBE command results.
Implemented Proper Caching: We modified our code to properly store and retrieve the table descriptions.
Monitored Performance: We closely watched the system performance and the graph in Zabbix. The result was a noticeable improvement.

Conclusion

The discovery that the DESCRIBE command creates temporary tables in MySQL/MariaDB was an unexpected revelation that solved a long-standing mystery. By understanding this behavior and implementing proper caching, we were able to boost our system's performance.

Sometimes, the solutions to complex problems are hidden in the most unexpected places. This experience reminds us to leave no stone unturned in our pursuit of understanding and optimizing our systems. Whether you're a seasoned database administrator or new to MySQL/MariaDB, I hope this article sheds light on a lesser-known aspect of these database systems and helps you in your journey.

Dependency Injection in Mako Framework for PHP

n0nag0n — Sat, 29 Jul 2023 20:57:01 +0000

Dependency injection is so important in the architecture of your PHP app. When you start out with a tiny project, it's workable without it. When that project gets bigger, oh man! So let's go over Dependency Injection in the Mako Framework!

Understanding Dependency Injection

Let's say we have a Car class and this class needs an instance of an Engine class to work. Instead of creating an instance of the Engine class inside the Car class, we "inject" the Engine instance into the Car when we create it. This is the core idea of Dependency Injection.

Registering a Dependency

In Mako, we can register these dependencies in a container. The container is a special object that holds and manages instances of our classes. When we register a dependency, we're telling the container how to create an instance of a certain class.

Here's an example of how to register a dependency:

$container->register(EngineInterface::class, Engine::class);

In this case, EngineInterface::class is the key we use to refer to the dependency in the container, and Engine::class is the concrete class that will be instantiated when we ask the container for this dependency.

Registering a Dependency with a Key

We can also associate a key with our dependency. This can make our code easier to read and write, and it also allows us to access our dependencies in a more flexible way.

$container->register([EngineInterface::class, 'engine'], Engine::class);

In this example, we're associating the key 'engine' with our Engine::class dependency. Now we can retrieve our Engine instance from the container using either EngineInterface::class or 'engine' as the key.

Registering a Dependency with a Closure

Sometimes, creating an instance of a class might involve some complex logic or additional configuration. In these cases, we can use a closure to define how the instance should be created.

$container->register([WheelInterface::class, 'wheel'], fn ($container) => new Wheel('parameter value'));

Here, we're telling the container to create a new instance of Wheel with 'parameter value' as an argument. The closure gives us a lot of flexibility when it comes to creating our instances.

Registering a Singleton Dependency

Sometimes, we want to ensure that there's only one instance of a certain class in our application. There are times like when you only want one guaranteed instance of a Database Connection no matter how many times you call a service from a container. This is known as a singleton. We can register a singleton dependency in the container like this:

$container->registerSingleton([EngineInterface::class, 'engine'], fn ($container) => new Engine('parameter value'));

Now, every time we ask the container for the 'engine' dependency, it will always return the same instance of Engine.

Registering an Existing Instance

If we already have an instance of a class and we want to register it in the container, we can do so using the registerInstance method.

$container->registerInstance([WheelInterface::class, 'wheel'], new Wheel('parameter value'));

This can be useful if we need to register an instance that was created outside of the container, or if we want to share a specific instance across different parts of our application.

Resolving a Dependency

Once we've registered our dependencies in the container, we can retrieve them using the get method. This is known as resolving a dependency.

$engine = $container->get(EngineInterface::class);

Or using the optional key:

$engine = $container->get('engine');

When we resolve a dependency, the container will give us an instance of the class associated with the given key. If the dependency was registered with a closure, the container will execute the closure to create the instance.

And that's it! You now know how to add a new dependency to the application container using the Mako PHP framework. Remember, the key to understanding Dependency Injection is practice, so don't hesitate to experiment with these concepts in your own projects. Happy coding!

DEV Community: n0nag0n

Back Up Multiple Drives to Backblaze with Deduplication – Introducing b2-dedup

Why Backblaze B2 Beats S3, Azure Blob, and Most Alternatives (for Backup Use Cases)

What b2-dedup Does (and Why You Need It for Multi-Drive Backups)

Step-by-Step Tutorial: Install & Use b2-dedup

1. Prerequisites

2. Install

3. Authenticate

4. Recommended Workflow for Multiple Drives

5. Useful Flags

6. Where Files End Up in B2

Tips & Gotchas

Wrap-Up

Supercharge Your PHP Projects with Flight's Native AI Integration in 2026

Start Fast: Use the Official Skeleton with Runway Built-In

Set Up AI Credentials with ai:init

Generate Smart Instructions with ai:generate-instructions

Why This Matters: Backwards Compatibility and Longevity

Quick Example: AI-Assisted Route in Skeleton

2026 Best PHP Micro Frameworks: Slim, Flight, Fat-Free, and More!

Slim PHP

Flight PHP

Fat-Free Framework (F3)

Phalcon Micro

Honorable Mentions

Comparisons and Verdict

Laravel vs. Flight: A Guide to Picking Your PHP Framework

What’s the Deal with Laravel?

Flight: The Easygoing Alternative

Building a Simple User API: Flight vs. Laravel

Flight: Fast and Straightforward

Laravel: The Whole Toolkit

Flight vs. Laravel: The Lowdown

Why Flight Might Click?

Why Laravel Still Shines?

Your Call!

2025 Best PHP Micro Frameworks: Slim, Flight, Fat-Free, Lumen, and More!

The Top Four: Slim, Flight, Fat-Free, and Lumen

Slim PHP: The Lean, Mean Routing Machine

Flight PHP: The Rising Star Ready to Soar

Fat-Free Framework (F3): The Minimalist Veteran

Lumen: The Laravel Lightweight (But Let’s Be Real…)

Honorable Mentions: Hidden Gems of 2025

The Verdict: Which One Wins in 2025?

Building a Pokémon API in PHP: A Beginner's Guide

Step 1: Setting up the Environment

Step 2: Installing Composer

Step 3: Installing Dependencies

Step 4: Setting Up index.php

Step 5: Adding Routes

Step 6: Rendering Views with Latte

Step 7: Grouping and Adding More Routes

Step 8: Does it work?

Troubleshooting

Best PHP Micro Frameworks for 2024

Introduction

Slim Framework

Community Level

Simplicity

Performance

Ease of Use

Flight Framework

Community Level

Simplicity

Performance

Ease of Use

Fat-Free Framework (F3)

Community Level

Simplicity

Performance

Ease of Use

Silex Framework

Community Level

Simplicity

Performance

Ease of Use

Lumen Framework

Community Level

Simplicity

Performance

Set Up AI Credentials with `ai:init`

Generate Smart Instructions with `ai:generate-instructions`

Step 4: Setting Up `index.php`

What is the `DESCRIBE` Command?