### Practical Controller Example (PHP)

Source: https://context7.com/doppar/framework/llms.txt

A complete controller method demonstrating the use of environment checks, authentication, caching, order creation, logging, email sending, and redirects with success messages.

```php
class OrderController extends Controller {
    public function process(Request $request) {
        // Validate environment
        if (!env('PAYMENT_ENABLED', false)) {
            abort(503, 'Payment processing unavailable');
        }

        // Check authentication
        if (!auth()->check()) {
            return redirect('/login')
                ->with('error', trans('messages.login_required'));
        }

        $user = auth()->user();

        // Get cached data
        $products = cache()->stash('products', 3600, function() {
            return Product::query()->where('active', true)->get();
        });

        // Create order
        $order = Order::create([
            'user_id' => $user->id,
            'total' => request('total'),
            'items' => request('items')
        ]);

        // Log activity
        logger()->info('Order created', [
            'order_id' => $order->id,
            'user_id' => $user->id,
            'total' => $order->total
        ]);

        // Send confirmation
        Mail::to($user)->send(new OrderConfirmation($order));

        // Redirect with message
        return redirect()->route('orders.show', $order->id)
            ->with('success', trans('messages.order.success'));
    }
}
```

--------------------------------

### Handling Requests and Responses (PHP)

Source: https://context7.com/doppar/framework/llms.txt

Illustrates how to get input from requests, retrieve multiple input fields at once, get the Request instance, and create custom responses with status codes and headers, including JSON responses.

```php
// Request and Response
$email = request('email'); // Get input
$data = request(['name', 'email']); // Get multiple inputs
$req = request(); // Get Request instance

$response = response('Hello', 200, ['X-Custom' => 'value']);
$json = response()->json(['data' => $users]);
```

--------------------------------

### Create Custom Console Commands in PHP

Source: https://context7.com/doppar/framework/llms.txt

Demonstrates how to build custom CLI commands using the Doppar framework's `Command` class. It includes examples of defining command signatures, descriptions, handling arguments and options, and performing actions like generating reports and cleaning data. Commands are registered in `app/Console/Kernel.php` or a service provider.

```php
use Phaseolies\Console\Command;

class SendReportCommand extends Command {
    // Command signature with arguments and options
    protected $signature = 'report:send {user} {--type=daily} {--email=}';

    // Command description
    protected $description = 'Send report to specified user';

    // Command execution
    public function handle() {
        // Get arguments
        $userId = $this->argument('user');

        // Get options
        $type = $this->option('type');
        $email = $this->option('email');

        // Output information
        $this->info("Processing report for user: {$userId}");
        $this->line("Report type: {$type}");

        $user = User::find($userId);

        if (!$user) {
            $this->error("User not found: {$userId}");
            return 1; // Exit code 1 indicates failure
        }

        // Show progress
        $this->info('Generating report...');
        $report = $this->generateReport($user, $type);

        $this->info('Sending email...');
        $this->sendEmail($email ?? $user->email, $report);

        // Success message
        $this->success("Report sent successfully to {$user->email}");

        // Warning example
        if ($type === 'weekly') {
            $this->warn('Weekly reports are being deprecated');
        }

        return 0; // Exit code 0 indicates success
    }

    private function generateReport($user, $type) {
        // Report generation logic
        return ['data' => 'report content'];
    }

    private function sendEmail($email, $report) {
        // Email sending logic
    }
}

class CleanupCommand extends Command {
    protected $signature = 'cleanup:old-data {--days=30} {--force}';
    protected $description = 'Clean up old data from database';

    public function handle() {
        $days = $this->option('days');
        $force = $this->option('force');

        $date = now()->subDays($days);

        $this->info("Finding records older than {$days} days (before {$date})...");

        $count = Post::query()
            ->where('status', 'draft')
            ->where('created_at', '<', $date)
            ->count();

        $this->line("Found {$count} records to delete");

        if (!$force) {
            $this->warn('Use --force flag to actually delete the records');
            return 0;
        }

        // Delete old records
        Post::query()
            ->where('status', 'draft')
            ->where('created_at', '<', $date)
            ->delete();

        $this->success("Deleted {$count} old draft posts");

        return 0;
    }
}

// Register commands in app/Console/Kernel.php or service provider
// $console->register(SendReportCommand::class);
// $console->register(CleanupCommand::class);

// Run commands:
// php doppar report:send 123 --type=weekly --email=admin@example.com
// php doppar cleanup:old-data --days=60 --force

```

--------------------------------

### Translation and Session Management (PHP)

Source: https://context7.com/doppar/framework/llms.txt

Explains how to translate language strings with placeholders, get the translator instance, set the locale, store data in the session, retrieve session data with defaults, and use flash messages.

```php
// Translation
$message = trans('messages.welcome', ['name' => 'John']);
$translator = lang();
lang()->setLocale('es');

// Session
session()->put('key', 'value');
$value = session('key', 'default');
session()->flash('success', 'Saved!');
```

--------------------------------

### Date and Time Manipulation (PHP)

Source: https://context7.com/doppar/framework/llms.txt

Shows how to get the current timestamp as a Carbon instance, perform date/time additions, and format dates into strings.

```php
// Date and time
$now = now(); // Current Carbon instance
$tomorrow = now()->addDay();
$formatted = now()->format('Y-m-d H:i:s');
```

--------------------------------

### Store and Retrieve Cached Data with PHP

Source: https://context7.com/doppar/framework/llms.txt

Demonstrates basic and advanced cache operations using the Phaseolies cache facade. Supports setting, getting, remembering, storing forever, adding, checking existence, deleting, and clearing cache entries. It also shows how to increment and decrement numeric cache values. This system helps improve application performance by reducing redundant computations and database queries.

```php
use Phaseolies\Support\Facades\Cache;

class DashboardController extends Controller {
    public function index() {
        // Basic cache operations
        Cache::set('site_stats', ['users' => 1000, 'posts' => 5000], 3600); // 1 hour TTL

        $stats = Cache::get('site_stats');

        if ($stats === null) {
            $stats = $this->calculateStats();
            Cache::set('site_stats', $stats, 3600);
        }

        // Remember pattern (fetch from cache or execute callback)
        $users = Cache::stash('all_users', 3600, function() {
            return User::query()
                ->where('status', 'active')
                ->get();
        });

        // Store forever (no expiration)
        Cache::forever('app_settings', $settings);

        // Add if not exists
        $added = Cache::add('feature_flag', true, 3600);

        if ($added) {
            // Key didn't exist, value was added
        }

        // Check if key exists
        if (Cache::has('user_session')) {
            $data = Cache::get('user_session');
        }

        // Delete from cache
        Cache::delete('old_data');
        Cache::forget('temporary_key'); // Alias for delete

        // Clear all cache
        Cache::clear();

        return view('dashboard', compact('stats', 'users'));
    }

    public function incrementPageViews($slug) {
        $key = "page_views:{$slug}";

        // Initialize if not exists
        if (!Cache::has($key)) {
            Cache::set($key, 0, 86400); // 24 hours
        }

        // Increment counter
        $views = Cache::increment($key);

        // Decrement also available
        // Cache::decrement($key);

        return response()->json(['views' => $views]);
    }
}

```

--------------------------------

### Accessing Application Container and Environment Variables (PHP)

Source: https://context7.com/doppar/framework/llms.txt

Demonstrates how to retrieve the application instance, resolve services from the container with or without parameters, and access environment variables with default values.

```php
// Application container
$app = app(); // Get Application instance
$request = app('request'); // Resolve from container
$db = app('db', ['connection' => 'mysql']); // With parameters

// Environment variables
$debug = env('APP_DEBUG', false);
$dbHost = env('DB_HOST', '127.0.0.1');
```

--------------------------------

### Configuration Management (PHP)

Source: https://context7.com/doppar/framework/llms.txt

Shows how to retrieve configuration values, set configuration values dynamically, and access nested configuration options.

```php
// Configuration
$appName = config('app.name');
$dbConnection = config('database.default');
config(['app.timezone' => 'America/New_York']); // Set config
```

--------------------------------

### Manage Shopping Cart with Session Data

Source: https://context7.com/doppar/framework/llms.txt

Handles adding items to a shopping cart, viewing the cart contents, clearing the cart, and processing checkout by interacting with session data. It utilizes session `get`, `put`, `flash`, `forget`, and `pull` methods. Product details and totals are managed within the session.

```php
use Phaseolies\Support\Session;

class CartController extends Controller {
    public function addToCart(Request $request, $productId) {
        $product = Product::find($productId);

        if (!$product) {
            return redirect()->back()
                ->with('error', 'Product not found');
        }

        // Get existing cart from session
        $cart = session()->get('cart', []);

        // Add product to cart
        if (isset($cart[$productId])) {
            $cart[$productId]['quantity']++;
        } else {
            $cart[$productId] = [
                'name' => $product->name,
                'price' => $product->price,
                'quantity' => 1
            ];
        }

        // Store updated cart in session
        session()->put('cart', $cart);

        // Flash success message
        session()->flash('success', "Added {$product->name} to cart");

        return redirect()->back();
    }

    public function viewCart() {
        $cart = session()->get('cart', []);
        $total = 0;

        foreach ($cart as $item) {
            $total += $item['price'] * $item['quantity'];
        }

        return view('cart.index', compact('cart', 'total'));
    }

    public function clearCart() {
        // Remove specific session key
        session()->forget('cart');

        return redirect()->route('cart.index')
            ->with('success', 'Cart cleared');
    }

    public function checkout(Request $request) {
        $cart = session()->get('cart', []);

        if (empty($cart)) {
            return redirect()->route('cart.index')
                ->with('error', 'Your cart is empty');
        }

        // Process order
        $order = $this->createOrder($cart);

        // Pull (get and remove) cart from session
        $processedCart = session()->pull('cart');

        return redirect()->route('orders.show', $order->id)
            ->with('success', 'Order placed successfully');
    }
}
```

--------------------------------

### View Rendering and Authentication (PHP)

Source: https://context7.com/doppar/framework/llms.txt

Demonstrates how to render views with data, pass compact data, retrieve the authenticated user, check login status, and log out the current user.

```php
// Views
return view('welcome', ['name' => 'John']);
return view('posts.index', compact('posts'));

// Authentication
$user = auth()->user();
$isLoggedIn = auth()->check();
auth()->logout();
```

--------------------------------

### Create and Render Views using PHP Template Engine

Source: https://context7.com/doppar/framework/llms.txt

Demonstrates how to create and render views using a PHP-based template engine. This includes controller logic for fetching data, a layout template with sections, and specific view templates that extend the layout and define content blocks. It utilizes features like data binding, inheritance, and sections for dynamic content generation.

```php
// Controller
class PostController extends Controller {
    public function index() {
        $posts = Post::query()
            ->where('status', 'published')
            ->orderBy('created_at', 'DESC')
            ->paginate(15);

        return view('posts.index', [
            'posts' => $posts,
            'title' => 'All Posts'
        ]);
    }

    public function show($id) {
        $post = Post::query()
            ->with(['author', 'comments'])
            ->find($id);

        if (!$post) {
            abort(404, 'Post not found');
        }

        return view('posts.show', compact('post'));
    }
}

// Layout: resources/views/layouts/app.php
<!DOCTYPE html>
<html lang="<?= config('app.locale') ?>">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title><?php $this->block('title', config('app.name')); ?></title>
    <link rel="stylesheet" href="/css/app.css">
    <?php $this->block('styles'); ?>
</head>
<body>
    <nav>
        <a href="<?= url('/') ?>">Home</a>
        <?php if (auth()->check()): ?>
            <a href="<?= route('profile') ?>">Profile</a>
            <form method="POST" action="<?= url('/logout') ?>">
                <button type="submit">Logout</button>
            </form>
        <?php else: ?>
            <a href="<?= url('/login') ?>">Login</a>
        <?php endif; ?>
    </nav>

    <?php if (session()->has('success')):
        <div class="alert success">
            <?= session('success') ?>
        </div>
    <?php endif; ?>

    <?php if (session()->has('error')):
        <div class="alert error">
            <?= session('error') ?>
        </div>
    <?php endif; ?>

    <main>
        <?php $this->block('content'); ?>
    </main>

    <footer>
        <p>&copy; <?= date('Y') ?> <?= config('app.name') ?></p>
    </footer>

    <?php $this->block('scripts'); ?>
</body>
</html>

// View: resources/views/posts/index.php
<?php $this->addParent('layouts/app'); ?>

<?php $this->beginBlock('title'); ?>
<?= $title ?> - <?= config('app.name') ?>
<?php $this->endBlock(); ?>

<?php $this->beginBlock('content'); ?>
<h1><?= $title ?></h1>

<div class="posts-grid">
    <?php foreach ($posts as $post): ?>
        <article class="post-card">
            <h2>
                <a href="<?= url('/posts/' . $post->id) ?>">
                    <?= htmlspecialchars($post->title) ?>
                </a>
            </h2>
            <p class="post-meta">
                By <?= htmlspecialchars($post->author->name) ?>
                on <?= $post->created_at->format('M d, Y') ?>
            </p>
            <p><?= htmlspecialchars(substr($post->content, 0, 200)) ?>...</p>
            <a href="<?= url('/posts/' . $post->id) ?>">Read more</a>
        </article>
    <?php endforeach; ?>
</div>

<?php if (empty($posts)):
    <p>No posts found.</p>
<?php endif; ?>
<?php $this->endBlock(); ?>

// View: resources/views/posts/show.php
<?php $this->addParent('layouts/app'); ?>

<?php $this->beginBlock('title'); ?>
<?= htmlspecialchars($post->title) ?>
<?php $this->endBlock(); ?>

<?php $this->beginBlock('content'); ?>
<article class="post">
    <h1><?= htmlspecialchars($post->title) ?></h1>

    <div class="post-meta">
        <span>By <?= htmlspecialchars($post->author->name) ?></span>
        <span><?= $post->created_at->format('F d, Y') ?></span>
        <span><?= $post->views ?> views</span>
    </div>

    <div class="post-content">
        <?= nl2br(htmlspecialchars($post->content)) ?>
    </div>

    <section class="comments">
        <h2>Comments (<?= $post->comments->count() ?>)</h2>

        <?php foreach ($post->comments as $comment):
            <div class="comment">
                <p><strong><?= htmlspecialchars($comment->author->name) ?></strong></p>
                <p><?= htmlspecialchars($comment->content) ?></p>
                <p class="comment-date"><?= $comment->created_at->diffForHumans() ?></p>
            </div>
        <?php endforeach; ?>
    </section>
</article>
<?php $this->endBlock(); ?>
```

--------------------------------

### Database Migrations and Seeding with Doppar CLI

Source: https://context7.com/doppar/framework/llms.txt

Run database migrations, rollbacks, resets, and seed the database using the Doppar CLI. These commands manage the evolution of your database schema and populate it with initial data.

```bash
php doppar migrate                  # Run database migrations
php doppar migrate:rollback         # Rollback last migration
php doppar migrate:reset            # Rollback all migrations
php doppar migrate:fresh            # Drop all tables and re-run migrations
php doppar db:seed                  # Seed database with records
```

--------------------------------

### Doppar Framework Built-in Commands Overview

Source: https://context7.com/doppar/framework/llms.txt

A categorized list of essential built-in commands provided by the Doppar framework. These commands cover cache management, code generation for various application components, and utility functions for application maintenance and configuration.

```bash
# Cache management
php doppar cache:clear              # Clear application cache
php doppar config:cache             # Cache configuration files
php doppar config:clear             # Clear configuration cache
php doppar route:cache              # Cache route definitions
php doppar route:clear              # Clear route cache
php doppar view:cache               # Cache compiled views
php doppar view:clear               # Clear view cache
php doppar session:clear            # Clear session data

# Code generation
php doppar make:controller UserController     # Create controller
php doppar make:model Post                    # Create model
php doppar make:middleware CheckAge           # Create middleware
php doppar make:console SendEmails            # Create console command
php doppar make:request CreateUserRequest     # Create form request
php doppar make:mail WelcomeEmail             # Create mailable
php doppar make:provider PaymentProvider      # Create service provider
php doppar make:auth                          # Scaffold authentication
php doppar make:authorizer                    # Create authorization logic
php doppar make:password                      # Scaffold password reset

# Utilities
php doppar key:generate             # Generate application key
php doppar route:list               # Display all registered routes
php doppar storage:link             # Create storage symlink
php doppar storage:unlink           # Remove storage symlink
php doppar app:boost                # Optimize application performance
php doppar vendor:publish           # Publish vendor assets
php doppar pagination:publish       # Publish pagination views
php doppar creatable:set            # Configure mass assignment

```

--------------------------------

### Logging and Error Handling (PHP)

Source: https://context7.com/doppar/framework/llms.txt

Demonstrates how to log simple messages, log with context, log errors, and abort the request with a specific HTTP status code and message.

```php
// Logging
logger('User logged in');
logger()->info('Processing order', ['order_id' => 123]);
logger()->error('Payment failed', ['error' => $e->getMessage()]);

// Abort with HTTP exception
abort(404, 'Page not found');
abort(403, 'Unauthorized access');
```

--------------------------------

### Implement Redirects with Flash Data in PHP

Source: https://context7.com/doppar/framework/llms.txt

This PHP snippet shows how to handle user redirects with session flash messages and input data using the Phaseolies framework. It covers redirecting to different URLs upon successful operations (e.g., user creation) and redirecting back with error messages and previously entered data when exceptions occur.

```php
class UserController extends Controller {
    public function store(Request $request) {
        try {
            $user = User::create($request->only(['name', 'email', 'password']));

            // Redirect with success message
            return redirect('/users')
                ->with('success', 'User created successfully');

        } catch (Exception $e) {
            // Redirect back with error and old input
            return redirect()->back()
                ->withErrors(['error' => 'Failed to create user: ' . $e->getMessage()])
                ->withInput();
        }
    }

    public function update(Request $request, $id) {
        $user = User::find($id);

        if (!$user) {
            return redirect()->route('users.index')
                ->with('error', 'User not found');
        }

        $user->update($request->only(['name', 'email']));

        // Redirect to named route with parameters
        return redirect()->route('users.show', ['id' => $user->id])
            ->with('success', 'User updated successfully');
    }

    public function delete($id) {
        $user = User::find($id);

        if (!$user) {
            return redirect()->back()
                ->with('error', 'User not found');
        }

        $user->delete();

        // Redirect to previous URL
        return redirect()->back()
            ->with('success', 'User deleted successfully');
    }
}

// In view: Display flash messages
// <?php if (session()->has('success')):
//     <div class="alert success"><?= session('success') ?></div>
// <?php endif; ?>
```

--------------------------------

### URL Generation and Redirects (PHP)

Source: https://context7.com/doppar/framework/llms.txt

Covers generating absolute and relative URLs, creating secure URLs, obtaining the URL generator instance, and performing various types of redirects including to a specific route or the previous page.

```php
// Redirects
return redirect('/home');
return redirect()->back();
return redirect()->route('users.show', ['id' => 1]);

// URL Generation
$url = url('/posts/1'); // http://example.com/posts/1
$secure = url('/api', [], true); // https://example.com/api
$generator = url(); // UrlGenerator instance
```

--------------------------------

### Generate JSON and View Responses in PHP

Source: https://context7.com/doppar/framework/llms.txt

This snippet demonstrates how to generate various HTTP responses in PHP using the Phaseolies framework. It covers creating JSON responses for API endpoints, rendering view responses for web pages, and setting custom headers. It also shows how to initiate file downloads and stream files directly in the browser.

```php
use Phaseolies\Http\Response;

class ApiController extends Controller {
    // JSON response
    public function index() {
        $users = User::query()
            ->where('status', 'active')
            ->get();

        return response()->json([
            'success' => true,
            'data' => $users,
            'total' => $users->count()
        ], 200);
    }

    // Error response
    public function show($id) {
        $user = User::find($id);

        if (!$user) {
            return response()->json([
                'success' => false,
                'error' => 'User not found'
            ], 404);
        }

        return response()->json([
            'success' => true,
            'data' => $user
        ]);
    }

    // View response
    public function dashboard() {
        $stats = [
            'users' => User::count(),
            'posts' => Post::count(),
            'revenue' => Order::sum('total')
        ];

        return view('admin.dashboard', [
            'stats' => $stats,
            'recentOrders' => Order::query()->latest()->limit(10)->get()
        ]);
    }

    // Custom response with headers
    public function download() {
        return response()->json(['data' => 'export data'])
            ->header('Content-Type', 'application/json')
            ->header('X-Custom-Header', 'value');
    }

    // File download
    public function downloadReport() {
        $path = storage_path('reports/monthly_report.pdf');
        return response()->download($path, 'report.pdf');
    }

    // Stream file in browser
    public function viewPdf() {
        $path = storage_path('documents/document.pdf');
        return response()->file($path);
    }
}
```

--------------------------------

### Create and Send Emails with Attachments in PHP

Source: https://context7.com/doppar/framework/llms.txt

Defines Mailable classes for custom email content and attachments, and demonstrates sending these emails from controllers. Supports template rendering and custom attachments with specified names and MIME types.

```php
use Phaseolies\Support\Mail\Mailable;
use Phaseolies\Support\Facades\Mail;

// Create Mailable class: app/Mail/WelcomeMail.php
class WelcomeMail extends Mailable {
    protected $user;
    protected $verificationUrl;

    public function __construct($user, $verificationUrl) {
        $this->user = $user;
        $this->verificationUrl = $verificationUrl;
    }

    public function subject() {
        $this->subject = 'Welcome to ' . config('app.name');
        return $this;
    }

    public function view() {
        return view('emails.welcome', [
            'user' => $this->user,
            'verificationUrl' => $this->verificationUrl
        ]);
    }

    public function attachment() {
        return [
            storage_path('docs/user-guide.pdf') => [
                'as' => 'getting-started.pdf',
                'mime' => 'application/pdf'
            ]
        ];
    }
}

// Order confirmation email
class OrderConfirmationMail extends Mailable {
    protected $order;

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

    public function subject() {
        $this->subject = 'Order Confirmation #' . $this->order->id;
        return $this;
    }

    public function view() {
        return view('emails.order-confirmation', [
            'order' => $this->order,
            'items' => $this->order->items,
            'total' => $this->order->total
        ]);
    }
}

// Send emails in controllers
class UserController extends Controller {
    public function register(Request $request) {
        $user = User::create([
            'name' => $request->name,
            'email' => $request->email,
            'password' => password_hash($request->password, PASSWORD_BCRYPT)
        ]);

        $verificationUrl = url('/verify-email/' . $user->verification_token);

        // Send welcome email
        Mail::to($user)->send(new WelcomeMail($user, $verificationUrl));

        return redirect('/login')
            ->with('success', 'Registration successful! Check your email to verify your account.');
    }

    public function sendToMultiple() {
        $admins = User::query()->where('role', 'admin')->get();

        foreach ($admins as $admin) {
            Mail::to($admin->email, $admin->name)
                ->send(new AdminNotification($data));
        }
    }
}

class OrderController extends Controller {
    public function checkout(Request $request) {
        $order = Order::create([
            'user_id' => auth()->id(),
            'total' => $request->total,
            'status' => 'pending'
        ]);

        // Add order items
        foreach ($request->items as $item) {
            $order->items()->create($item);
        }

        // Send confirmation email with CC and BCC
        Mail::to(auth()->user())
            ->cc(['manager@example.com'])
            ->bcc(['orders@example.com', 'accounting@example.com'])
            ->send(new OrderConfirmationMail($order));

        return redirect()->route('orders.show', $order->id)
            ->with('success', 'Order placed successfully!');
    }
}

```

```html
<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <style>
        body { font-family: Arial, sans-serif; line-height: 1.6; }
        .container { max-width: 600px; margin: 0 auto; padding: 20px; }
        .button { background: #007bff; color: white; padding: 10px 20px; text-decoration: none; border-radius: 5px; display: inline-block; }
    </style>
</head>
<body>
    <div class="container">
        <h1>Welcome, <?= htmlspecialchars($user->name) ?>!</h1>

        <p>Thank you for registering with <?= config('app.name') ?>. We're excited to have you on board!</p>

        <p>Please verify your email address by clicking the button below:</p>

        <p>
            <a href="<?= $verificationUrl ?>" class="button">Verify Email</a>
        </p>

        <p>If you didn't create an account, please ignore this email.</p>

        <p>Best regards,<br><?= config('app.name') ?> Team</p>
    </div>
</body>
</html>

```

--------------------------------

### Collection Operations (PHP)

Source: https://context7.com/doppar/framework/llms.txt

Illustrates creating a collection, filtering its items based on a condition, and mapping items to new values.

```php
// Collections
$collection = collect([1, 2, 3, 4, 5]);
$filtered = $collection->filter(fn($n) => $n > 3);
$mapped = $collection->map(fn($n) => $n * 2);
```

--------------------------------

### Translate Application Text (PHP)

Source: https://context7.com/doppar/framework/llms.txt

Defines language files for multiple locales (English and Spanish) and demonstrates their usage in controllers, views, and middleware for dynamic translation and locale management. Supports simple strings, nested keys, and parameterized replacements.

```php
// Language file: lang/en/messages.php
<?php
return [
    'welcome' => 'Welcome to :app',
    'goodbye' => 'Goodbye, :name!',
    'login' => [
        'title' => 'Login to your account',
        'email' => 'Email Address',
        'password' => 'Password',
        'submit' => 'Sign In',
        'remember' => 'Remember me'
    ],
    'validation' => [
        'required' => 'The :field field is required',
        'email' => 'Please enter a valid email address',
        'min' => 'The :field must be at least :min characters'
    ],
    'posts' => [
        'not_found' => 'Post not found',
        'created' => 'Post created successfully',
        'updated' => 'Post updated successfully',
        'deleted' => 'Post deleted successfully',
        'count' => '{0} No posts|{1} One post|[2,*] :count posts'
    ]
];

// Language file: lang/es/messages.php
<?php
return [
    'welcome' => 'Bienvenido a :app',
    'goodbye' => '¡Adiós, :name!',
    'login' => [
        'title' => 'Inicia sesión en tu cuenta',
        'email' => 'Correo Electrónico',
        'password' => 'Contraseña',
        'submit' => 'Iniciar Sesión',
        'remember' => 'Recuérdame'
    ],
    'validation' => [
        'required' => 'El campo :field es obligatorio',
        'email' => 'Por favor ingrese un correo válido',
        'min' => 'El :field debe tener al menos :min caracteres'
    ],
    'posts' => [
        'not_found' => 'Publicación no encontrada',
        'created' => 'Publicación creada exitosamente',
        'updated' => 'Publicación actualizada exitosamente',
        'deleted' => 'Publicación eliminada exitosamente',
        'count' => '{0} Sin publicaciones|{1} Una publicación|[2,*] :count publicaciones'
    ]
];

// Usage in controllers
class WelcomeController extends Controller {
    public function index() {
        // Simple translation
        $welcome = trans('messages.welcome', ['app' => config('app.name')]);
        // Output: "Welcome to MyApp"

        // Nested keys
        $loginTitle = trans('messages.login.title');
        // Output: "Login to your account"

        // With replacements
        $goodbye = trans('messages.goodbye', ['name' => auth()->user()->name]);
        // Output: "Goodbye, John!"

        // Get current locale
        $locale = lang()->getLocale(); // 'en'

        // Change locale at runtime
        lang()->setLocale('es');

        // Translate with specific locale
        $spanishWelcome = trans('messages.welcome', ['app' => 'MiApp'], 'es');
        // Output: "Bienvenido a MiApp"

        return view('welcome', compact('welcome'));
    }

    public function setLocale(Request $request, $locale) {
        $availableLocales = ['en', 'es', 'fr', 'de'];

        if (!in_array($locale, $availableLocales)) {
            return redirect()->back();
        }

        // Change application locale
        app()->setLocale($locale);

        // Store preference in session
        session()->put('locale', $locale);

        return redirect()->back()
            ->with('success', trans('messages.locale_changed'));
    }
}

// Middleware to set locale from session
class SetLocale implements Middleware {
    public function __invoke(Request $request, Closure $next, ...$params) {
        $locale = session()->get('locale', config('app.locale'));

        app()->setLocale($locale);
        lang()->setLocale($locale);

        return $next($request);
    }
}

// In views
// <h1><?= trans('messages.login.title') ?></h1>
// <p><?= trans('messages.posts.count', ['count' => $posts->count()]) ?></p>

```

--------------------------------

### Group Routes with Middleware and Prefixes in Phaseolies

Source: https://context7.com/doppar/framework/llms.txt

Organizing related routes using `Router::group`. Allows for shared attributes like middleware, URL prefixes, and namespaces. Supports nested groups and multiple middleware.

```php
// Group with prefix and middleware
Router::group(['prefix' => 'admin', 'middleware' => 'auth'], function() {
    Router::get('/dashboard', [AdminController::class, 'dashboard']);
    Router::get('/users', [AdminController::class, 'users']);
    Router::post('/users', [AdminController::class, 'createUser']);
});

// Nested groups
Router::group(['prefix' => 'api/v1'], function() {
    Router::group(['middleware' => 'auth:api'], function() {
        Router::get('/user', [ApiUserController::class, 'show']);
        Router::put('/user', [ApiUserController::class, 'update']);
    });

    // Public API endpoints
    Router::get('/posts', [ApiPostController::class, 'index']);
});

// Multiple middleware
Router::group(['middleware' => ['auth', 'verified', 'admin']], function() {
    Router::resource('/products', ProductController::class);
});
```

--------------------------------

### Define HTTP Routes with Phaseolies Router

Source: https://context7.com/doppar/framework/llms.txt

Registering routes using static methods on the Router class. Supports various HTTP verbs, route parameters, named routes, and URL generation. Requires the Phaseolies namespace.

```php
use Phaseolies\Support\Router;
use App\Http\Controllers\UserController;
use App\Http\Controllers\PostController;

// Basic GET route
Router::get('/users', [UserController::class, 'index']);

// POST route with controller action
Router::post('/users', [UserController::class, 'store']);

// Route parameters
Router::get('/users/{id}', [UserController::class, 'show']);
Router::get('/posts/{slug}/comments/{commentId}', [PostController::class, 'showComment']);

// Multiple HTTP verbs
Router::match(['GET', 'POST'], '/contact', [ContactController::class, 'handle']);

// Any HTTP verb
Router::any('/webhook', [WebhookController::class, 'process']);

// Named routes for URL generation
Router::get('/profile', [ProfileController::class, 'show'])
    ->name('profile.show');

// Generate URL from named route
$url = route('profile.show'); // Returns: /profile
```

--------------------------------

### Build Complex SQL Queries with Query Builder

Source: https://context7.com/doppar/framework/llms.txt

Utilize the chainable query builder for constructing SQL queries with features like selecting/excluding columns, raw expressions, various WHERE clause operators, LIKE, BETWEEN, and joins. It supports conditional query building and automatic parameter binding.

```php
use Phaseolies\Database\Entity\Query\Builder;

// Select specific columns
$users = User::query()
    ->select(['id', 'name', 'email'])
    ->where('status', 'active')
    ->get();

// Exclude columns
$users = User::query()
    ->omit('password', 'remember_token')
    ->get();

// Raw select expressions
$users = User::query()
    ->selectRaw('COUNT(*) as user_count, role')
    ->groupBy('role')
    ->get();

// WHERE clauses with operators
$products = Product::query()
    ->where('price', '>', 100)
    ->where('stock', '<=', 10)
    ->orWhere('featured', true)
    ->get();

// WHERE IN and WHERE NULL
$users = User::query()
    ->whereIn('role', ['admin', 'moderator'])
    ->whereNotNull('email_verified_at')
    ->get();

// LIKE searches
$users = User::query()
    ->whereLike('name', '%john%', false) // Case-insensitive
    ->get();

// BETWEEN clause
$orders = Order::query()
    ->whereBetween('total', [100, 500])
    ->get();

// Joins
$posts = Post::query()
    ->select(['posts.*', 'users.name as author_name'])
    ->join('users', 'posts.user_id', '=', 'users.id')
    ->where('users.status', 'active')
    ->get();

// Conditional queries
$query = Product::query();

if ($request->has('category')) {
    $query->where('category', $request->category);
}

if ($request->has('min_price')) {
    $query->where('price', '>=', $request->min_price);
}

$products = $query->get();

// Using if() method for conditional queries
$products = Product::query()
    ->if($request->has('category'), function($q) use ($request) {
        $q->where('category', $request->category);
    })
    ->if($request->filled('search'), function($q) use ($request) {
        $q->whereLike('name', '%' . $request->search . '%');
    })
    ->get();
```

--------------------------------

### PHP User Authentication: Login, Logout, and Profile

Source: https://context7.com/doppar/framework/llms.txt

Handles user authentication, including login with credentials, session management, and logout. It supports remembering users and retrieving authenticated user details. Dependencies include the PhaseoliesAuthSecurityAuthenticate class and standard Laravel request/session handling.

```php
use Phaseolies\Auth\Security\Authenticate;

class AuthController extends Controller {
    public function login(Request $request) {
        $credentials = $request->only(['email', 'password']);
        $remember = $request->filled('remember');

        // Attempt login with credentials
        if (auth()->try($credentials, $remember)) {
            // Authentication successful
            session()->regenerate(); // Prevent session fixation

            return redirect()->intended('/dashboard')
                ->with('success', 'Welcome back!');
        }

        // Authentication failed
        return redirect()->back()
            ->withErrors(['email' => 'Invalid credentials'])
            ->withInput($request->except('password'));
    }

    public function loginWithId(Request $request) {
        $userId = $request->input('user_id');

        // Login user by ID
        $user = auth()->loginUsingId($userId, true);

        if ($user) {
            return redirect('/dashboard');
        }

        return redirect()->back()->withErrors(['error' => 'User not found']);
    }

    public function logout() {
        // Clear authentication session
        auth()->logout();

        session()->invalidate();
        session()->regenerateToken();

        return redirect('/')
            ->with('success', 'Logged out successfully');
    }

    public function profile() {
        // Check if user is authenticated
        if (!auth()->check()) {
            return redirect('/login')
                ->with('error', 'Please login to continue');
        }

        // Get authenticated user
        $user = auth()->user();
        $userId = auth()->id();

        // Check if logged in via remember cookie
        $viaRemember = auth()->viaRemember();

        return view('profile', [
            'user' => $user,
            'viaRemember' => $viaRemember
        ]);
    }
}
```

--------------------------------

### Cache Operations (PHP)

Source: https://context7.com/doppar/framework/llms.txt

Shows how to set cache items with an expiration time, retrieve cached items with a default value, and remove items from the cache.

```php
// Cache
cache()->set('key', 'value', 3600);
$value = cache('key', 'default');
cache()->forget('key');
```

--------------------------------

### PHP Model Hooks for Create, Update, Delete Events

Source: https://context7.com/doppar/framework/llms.txt

Defines hooks for various model lifecycle events in PHP. It demonstrates how to attach callback functions or class handlers to execute before or after create, update, and delete operations. Hooks can include conditional logic for execution.

```php
use Phaseolies\Database\Entity\Model;

class User extends Model {
    protected $creatable = ['name', 'email', 'password'];

    // Define hooks array
    protected $hooks = [
        'before_created' => [
            'handler' => function($model) {
                // Generate UUID before creating
                $model->uuid = \Ramsey\Uuid\Uuid::uuid4()->toString();

                // Hash password if not already hashed
                if (!password_get_info($model->password)['algo']) {
                    $model->password = password_hash($model->password, PASSWORD_BCRYPT);
                }
            },
            'when' => true // Always run
        ],

        'after_created' => [
            'handler' => CreateUserProfile::class,
            'when' => true
        ],

        'before_updated' => [
            'handler' => function($model) {
                // Log changes
                logger()->info('User updated', [
                    'user_id' => $model->id,
                    'changes' => $model->getDirty()
                ]);
            },
            'when' => function($model) {
                // Only run if specific fields changed
                return $model->isDirty(['name', 'email']);
            }
        ],

        'after_updated' => ClearUserCache::class,

        'before_deleted' => [
            'handler' => function($model) {
                // Delete related records
                $model->posts()->delete();
                $model->comments()->delete();
            },
            'when' => function($model) {
                return $model->posts()->count() > 0 || $model->comments()->count() > 0;
            }
        ],

        'after_deleted' => NotifyAdminOfDeletion::class
    ];

    public function posts() {
        return $this->linkMany(Post::class, 'user_id', 'id');
    }

    public function comments() {
        return $this->linkMany(Comment::class, 'user_id', 'id');
    }
}

// Hook handler class
class CreateUserProfile {
    public function handle(Model $user) {
        Profile::create([
            'user_id' => $user->id,
            'bio' => '',
            'avatar' => 'default-avatar.png'
        ]);

        // Send welcome email
        Mail::to($user)->send(new WelcomeMail($user));
    }
}

class ClearUserCache {
    public function handle(Model $user) {
        Cache::forget('user:' . $user->id);
        Cache::forget('user:profile:' . $user->id);
        Cache::forget('user:posts:' . $user->id);
    }
}

class NotifyAdminOfDeletion {
    public function handle(Model $user) {
        $admins = User::query()->where('role', 'admin')->get();

        foreach ($admins as $admin) {
            Mail::to($admin)->send(new UserDeletedNotification($user));
        }
    }
}

// Usage
class UserController extends Controller {
    public function store(Request $request) {
        // Hooks fire automatically
        $user = User::create([
            'name' => $request->name,
            'email' => $request->email,
            'password' => $request->password // Will be hashed by before_created hook
        ]);
        // after_created hook creates profile and sends email

        return redirect()->route('users.show', $user->id);
    }

    public function update(Request $request, $id) {
        $user = User::find($id);

        // before_updated logs changes, after_updated clears cache
        $user->update($request->only(['name', 'email']));

        return redirect()->back()->with('success', 'User updated');
    }

    public function delete($id) {
        $user = User::find($id);

        // before_deleted removes related records, after_deleted notifies admins
        $user->delete();

        return redirect()->route('users.index')->with('success', 'User deleted');
    }

    public function updateWithoutHooks($id) {
        // Disable hooks for this operation
        $user = User::withoutHook()->find($id);
        $user->update(['last_login' => now()]);

        // No hooks will fire
    }
}

```