$post->loadMissing(['comments', 'author']);
// With constraints
$post->loadMissing(['comments' => function($query) {
    $query->latest()->take(5);
}]);

<?php
 
namespace App\Http\Controllers;
 
use App\Models\Dashboard;
use Illuminate\Http\Request;
 
class DashboardController extends Controller
{
    public function show(Request $request, Dashboard $dashboard)
    {
        // Load base relationships
        $dashboard->loadMissing([
            'widgets',
            'owner',
        ]);
 
        // Conditionally load additional data
        if ($request->section === 'analytics') {
            $dashboard->loadMissing([
                'widgets.viewHistory' => function($query) {
                    $query->whereBetween('viewed_at', [
                        now()->subDays(30),
                        now()
                    ]);
                },
                'widgets.interactions'
            ]);
        }
 
        if ($request->section === 'sharing') {
            $dashboard->loadMissing([
                'sharedUsers',
                'shareLinks' => function($query) {
                    $query->where('expires_at', '>', now());
                }
            ]);
        }
        return $dashboard;
    }
}

// GET /dashboard/1?section=analytics
{
    "id": 1,
    "name": "Sales Overview",
    "widgets": [
        {
            "id": 1,
            "type": "chart",
            "viewHistory": [
                {
                    "viewed_at": "2024-02-01T10:30:00Z",
                    "views": 150
                }
            ],
            "interactions": [
                {
                    "type": "filter_change",
                    "timestamp": "2024-02-01T11:20:00Z"
                }
            ]
        }
    ]
}

if ($request->route()->named('dashboard')) {
    // We're on the dashboard
}

<?php
 
namespace App\View\Components;
 
use Illuminate\View\Component;
use Illuminate\Http\Request;
 
class NavigationMenu extends Component
{
    public function __construct(private Request $request)
    {
    }
 
    public function isActive(string $routeName): bool
    {
        return $this->request->route()->named($routeName);
    }
 
    public function isActiveSection(string $section): bool
    {
        return $this->request->route()->named("$section.*");
    }
 
    public function render()
    {
        return view('components.navigation-menu', [
            'sections' => [
                'dashboard' => [
                    'label' => 'Dashboard',
                    'route' => 'dashboard',
                    'active' => $this->isActive('dashboard')
                ],
                'posts' => [
                    'label' => 'Blog Posts',
                    'route' => 'posts.index',
                    'active' => $this->isActiveSection('posts')
                ],
                'settings' => [
                    'label' => 'Settings',
                    'route' => 'settings.index',
                    'active' => $this->isActiveSection('settings')
                ]
            ]
        ]);
    }
}

use SaKanjo\EasyMetrics\Metrics\Value;
use App\Models\User;

$data = Value::make(User::class)
    ->count();

Value::make(User::class)
    ->min('age');

Value::make(User::class)
    ->max('age');

Value::make(User::class)
    ->sum('age');

Value::make(User::class)
    ->average('age');

Value::make(User::class)
    ->count();

use SaKanjo\EasyMetrics\Metrics\Doughnut;
use App\Models\User;
use App\Enums\Gender;

[$labels, $data] = Doughnut::make(User::class)
    ->options(Gender::class)
    ->count('gender');

Doughnut::make(User::class)
    ->min('age', 'gender');

Doughnut::make(User::class)
    ->max('age', 'gender');

Doughnut::make(User::class)
    ->sum('age', 'gender');

Doughnut::make(User::class)
    ->average('age', 'gender');

Doughnut::make(User::class)
    ->count('gender');

use SaKanjo\EasyMetrics\Metrics\Trend;
use App\Models\User;

[$labels, $data] = Trend::make(User::class)
    ->countByMonths();

$trend->minByYears('age'); 
$trend->minByMonths('age'); 
$trend->minByWeeks('age');  
$trend->minByDays('age');  
$trend->minByHours('age');  
$trend->minByMinutes('age');  

$trend->maxByYears('age'); 
$trend->maxByMonths('age'); 
$trend->maxByWeeks('age');  
$trend->maxByDays('age');  
$trend->maxByHours('age');  
$trend->maxByMinutes('age');  

$trend->sumByYears('age'); 
$trend->sumByMonths('age'); 
$trend->sumByWeeks('age');  
$trend->sumByDays('age');  
$trend->sumByHours('age');  
$trend->sumByMinutes('age');  

$trend->averageByYears('age'); 
$trend->averageByMonths('age'); 
$trend->averageByWeeks('age');  
$trend->averageByDays('age');  
$trend->averageByHours('age');  
$trend->averageByMinutes('age');  

$trend->countByYears(); 
$trend->countByMonths(); 
$trend->countByWeeks();  
$trend->countByDays();  
$trend->countByHours();  
$trend->countByMinutes();  

use SaKanjo\EasyMetrics\Metrics\Trend;
use SaKanjo\EasyMetrics\Metrics\Enums\Range;
use App\Models\User;

Value::make(User::class)
    ->range(30)
    ->ranges([
        15, 30, 365,
        Range::TODAY, // Or 'TODAY'
    ]);

<?php

namespace App\Filament\Widgets\Admin;

use App\Models\User;
use Filament\Widgets\ChartWidget;
use SaKanjo\EasyMetrics\Metrics\Trend;

class UsersCountChart extends ChartWidget
{
    protected static ?string $heading = 'Users count trend';

    protected function getData(): array
    {
        [$labels, $data] = Trend::make(User::class)
            ->range($this->filter)
            ->rangesFromOptions($this->getFilters())
            ->countByMonths();

        return [
            'datasets' => [
                [
                    'label' => 'Users',
                    'data' => $data,
                ],
            ],
            'labels' => $labels,
        ];
    }

    protected function getType(): string
    {
        return 'line';
    }

    protected function getFilters(): ?array
    {
        return [
            15 => '15 Months',
            30 => '30 Months',
            60 => '60 Months',
        ];
    }
}

<?php
use Illuminate\Support\Facades\Http;
use Illuminate\Support\Facades\Route;
use Psr\Http\Message\RequestInterface;
use Psr\Http\Message\ResponseInterface;


Route::get('http', function (){
    return response()->eventStream(function (){
        $stream = Http::withHeaders([
            'Authorization' => 'Bearer '.env('DEEPSEEK_API_KEY'),
            'Accept' => 'application/json',
        ])
            ->throw()
            //->accept('application/x-ndjson')
            ->asJson()
            ->timeout(2000)
            ->withOptions(['stream' => true])
            ->post(env('DEEPSEEK_API_BASE_URL').'/chat/completions',[
                'messages' => [
                    [
                        'content' => 'Hello',
                        'role' => 'system',
                    ],
                    [
                        'content' => '西南财经大学',
                        'role' => 'user',
                    ]
                ],
                'model' => 'deepseek_r1.deepseek-r1', //deepseek_r1.deepseek-r1
                'frequency_penalty' => 0,
                'max_tokens' => 2048,
                'presence_penalty' => 0,
                'response_format' => [
                    'type' => 'text'
                ],
                'stream' => true
            ])
            ->toPsrResponse()
            ->getBody();

        $buffer = '';
        while (!$stream->eof()) {
            $char = $stream->read(1);

            $buffer .= $char;
            if ($char === "\n") {
                $line = trim($buffer);
                $buffer = '';

                if (!empty($line)) {
                    yield $line;
                }
            }
        }
    });
});


Route::get('guzzle', function (){
    $client = new \GuzzleHttp\Client([
        'base_uri' => config('swufe-chat.base_url')
    ]);

    return response()->eventStream(function () use ($client){
        $response = $client->request('POST', '/api/chat/completions', [
            'headers' => [
                'Authorization' => 'Bearer '.env('DEEPSEEK_API_KEY'),
                'Accept' => 'application/json',
            ],
            'json' => [
                'messages' => [
                    [
                        'content' => 'Hello',
                        'role' => 'system',
                    ],
                    [
                        'content' => '西南财经大学',
                        'role' => 'user',
                    ]
                ],
                'model' => 'deepseek_r1.deepseek-r1', //deepseek_r1.deepseek-r1
                'frequency_penalty' => 0,
                'max_tokens' => 2048,
                'presence_penalty' => 0,
                'response_format' => [
                    'type' => 'text'
                ],
                'stream' => true
            ],
            'stream' => true
        ]);

        $stream = $response->getBody();
        $buffer = '';
        while (!$stream->eof()) {
            $char = $stream->read(1);

            $buffer .= $char;
            if ($char === "\n") {
                $line = trim($buffer);
                $buffer = '';

                if (!empty($line)) {
                    yield $line;
                }
            }
        }
    });
});


// https://github.com/openai-php/client

Route::get('openai', function (){
    $client = OpenAI::factory()
        ->withApiKey(env('DEEPSEEK_API_KEY'))
        ->withBaseUri(env('DEEPSEEK_API_BASE_URL'))
        ->withHttpClient($httpClient = new \GuzzleHttp\Client())
        ->withStreamHandler(fn (RequestInterface $request): ResponseInterface => $httpClient->send($request, [
            'stream' => true // Allows to provide a custom stream handler for the http client.
        ]))
        ->make();

    return response()->eventStream(function () use ($client){
        $stream = $client->chat()->createStreamed([
            'model' => 'deepseek_r1.deepseek-r1',
            'messages' => [
                ['role' => 'user', 'content' => 'Hello!'],
            ],
            'stream_options'=>[
                'include_usage' => true,
            ]
        ]);

        foreach ($stream as $response) {
            yield $response->choices[0];
        }
    });
});

$stream = Http::throw()
    ->accept('application/x-ndjson')
    ->asJson()
    ->withOptions(['stream' => true])
    ->post($endpoint, $requestData)
    ->toPsrResponse()
    ->getBody();

$buffer = '';

while ($stream->eof() === false) {
    $char = $stream->read(1);

    $buffer .= $char;
    if ($char === "\n") {
        $line = trim($buffer);
        $buffer = '';

        if (!empty($line)) {
            dump($line);
        }
    }
}