PHP code example of monkeyscloud / monkeyslegion

    
        
<?php
require_once('vendor/autoload.php');

/* Start to develop here. Best regards https://php-download.com/ */

    

monkeyscloud / monkeyslegion example snippets

declare(strict_types=1);

ootstrap/app.php';

$app
    ->withMiddleware([
        App\Middleware\CustomMiddleware::class,
    ])
    ->withBindings([
        App\Service\PaymentGateway::class => fn($c) => new App\Service\StripeGateway(
            apiKey: $_ENV['STRIPE_API_KEY'],
        ),
    ])
    ->run();

declare(strict_types=1);

namespace App\Controller;

use MonkeysLegion\Router\Attribute\Route;
use MonkeysLegion\Router\Attribute\Get;
use MonkeysLegion\Router\Attribute\Post;
use MonkeysLegion\Router\Attribute\Delete;
use Psr\Http\Message\ResponseInterface;

#[Route('/api/users', name: 'users')]
final class UserController
{
    #[Get('/', name: 'index')]
    public function index(): ResponseInterface
    {
        return json_response(['users' => []]);
    }

    #[Get('/{id:\d+}', name: 'show')]
    public function show(int $id): ResponseInterface
    {
        return json_response(['id' => $id]);
    }

    #[Post('/', name: 'create')]
    public function create(CreateUserRequest $request): ResponseInterface
    {
        // DTO is auto-validated via DtoBinder
        return json_response(['created' => true], 201);
    }

    #[Delete('/{id:\d+}', name: 'delete')]
    public function delete(int $id): ResponseInterface
    {
        return json_response(null, 204);
    }
}

use MonkeysLegion\Query\Query\QueryBuilder;

$qb = $container->get(QueryBuilder::class);

// Select
$users = $qb->select(['id', 'name', 'email'])
    ->from('users')
    ->where('status', '=', 'active')
    ->orderBy('created_at', 'DESC')
    ->limit(10)
    ->get();

// Joins
$posts = $qb->select(['posts.*', 'users.name as author'])
    ->from('posts')
    ->join('users', 'posts.user_id', '=', 'users.id')
    ->get();

// Transactions
$connection->transaction(function () use ($qb): void {
    $qb->insert('orders', ['total' => 100]);
    $qb->update('inventory', ['stock' => 'stock - 1']);
});

use MonkeysLegion\Auth\Service\AuthService;
use MonkeysLegion\Auth\Middleware\AuthenticationMiddleware;

// Login
$result = $authService->login([
    'email'    => '[email protected]',
    'password' => 'secret',
]);

if ($result->isAuthenticated()) {
    $tokens = $result->getTokens();
    // $tokens['access_token']
    // $tokens['refresh_token']
}

// Protect routes via middleware
#[Route('/admin', middleware: [AuthenticationMiddleware::class])]
final class AdminController { /* ... */ }

use MonkeysLegion\Validation\Attribute\Required;
use MonkeysLegion\Validation\Attribute\Email;
use MonkeysLegion\Validation\Attribute\MinLength;

final class CreateUserRequest
{
    #[Required]
    #[MinLength(3)]
    public string $name;

    #[Required]
    #[Email]
    public string $email;

    #[Required]
    #[MinLength(8)]
    public string $password;
}

// In controller — automatically validated and bound
#[Post('/users')]
public function create(CreateUserRequest $request): ResponseInterface
{
    // Invalid data returns 422 with structured errors
}

declare(strict_types=1);

namespace App\Provider;

use MonkeysLegion\Config\Providers\AbstractServiceProvider;
use MonkeysLegion\Framework\Attributes\Provider;
use MonkeysLegion\Framework\Attributes\BootAfter;
use MonkeysLegion\Config\Providers\DatabaseProvider;

#[Provider(priority: 10, context: 'all')]
#[BootAfter(DatabaseProvider::class)]
final class PaymentProvider extends AbstractServiceProvider
{
    public function getDefinitions(): array
    {
        return [
            PaymentGateway::class => fn($c) => new StripeGateway(
                apiKey: $_ENV['STRIPE_API_KEY'],
            ),
        ];
    }

    public function context(): string
    {
        return 'http'; // Only loaded during HTTP requests
    }
}

use MonkeysLegion\Template\Renderer;

public function index(Renderer $renderer): ResponseInterface
{
    return $renderer->render('welcome', [
        'title' => 'Home',
        'user'  => ['name' => 'John'],
        'posts' => $this->getPosts(),
    ]);
}

// Define event
final readonly class UserRegistered
{
    public function __construct(public int $userId) {}
}

// Register listener
$provider->addListener(UserRegistered::class, function (UserRegistered $event): void {
    // Send welcome email, audit log, etc.
});

// Dispatch
$dispatcher->dispatch(new UserRegistered($user->getAuthIdentifier()));

use MonkeysLegion\Apex\AI;

$ai = $container->get(AI::class);

// Chat completion
$response = $ai->chat([
    ['role' => 'user', 'content' => 'Explain PHP property hooks.'],
]);

echo $response->content;
echo $response->usage->totalTokens;

// Embeddings
$vector = $ai->embed('Search query text');

// Cost tracking (built-in)
$cost = $ai->getCostTracker()->getTotalCost();

use MonkeysLegion\Queue\Contracts\QueueInterface;

$queue = $container->get(QueueInterface::class);

// Dispatch job
$queue->push(new SendEmailJob($userId));

// Worker (CLI)
// php bin/ml queue:work --tries=3 --timeout=60

use MonkeysLegion\Files\FilesManager;
use MonkeysLegion\Files\Image\ImageProcessor;

$files = $container->get(FilesManager::class);
$image = $container->get(ImageProcessor::class);

// Store upload
$path = $files->store($uploadedFile, 'avatars');

// Process image
$image->process($path, [
    'resize' => [150, 150],
    'format' => 'webp',
]);

use MonkeysLegion\I18n\Translator;

$t = $container->get(Translator::class);

echo $t->trans('welcome.message');                         // "Welcome!"
echo $t->trans('user.greeting', ['name' => 'John']);       // "Hello, John"

$t->setLocale('es');
echo $t->trans('welcome.message');                         // "¡Bienvenido!"

use MonkeysLegion\Telemetry\Metrics\MetricsInterface;
use MonkeysLegion\Telemetry\Tracing\TracerInterface;

// Metrics
$metrics->counter('http_requests_total')->inc();
$metrics->histogram('response_time_ms')->observe($duration);

// Distributed tracing
$span = $tracer->startSpan('process_order');
// ... work ...
$span->end();

// Activate: create var/maintenance.php
file_put_contents('var/maintenance.php', ' return [
    "retry"   => 600,
    "message" => "Upgrading to v2.0...",
];');

// Bypass via secret: ?secret=bypass123
// Bypass via IP whitelist: configured in MiddlewareProvider

// Deactivate: remove the file
unlink('var/maintenance.php');

declare(strict_types=1);

namespace App\Middleware;

use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Server\MiddlewareInterface;
use Psr\Http\Server\RequestHandlerInterface;

final class ApiVersionMiddleware implements MiddlewareInterface
{
    public function process(
        ServerRequestInterface $request,
        RequestHandlerInterface $handler,
    ): ResponseInterface {
        $request = $request->withAttribute('api_version', 'v2');

        $response = $handler->handle($request);

        return $response->withHeader('X-API-Version', '2.0');
    }
}

declare(strict_types=1);

namespace Tests\Feature;

use MonkeysLegion\Framework\Application;
use PHPUnit\Framework\TestCase;

final class UserServiceTest extends TestCase
{
    private Application $app;

    protected function setUp(): void
    {
        $this->app = Application::create(basePath: dirname(__DIR__));
    }

    public function testContainerResolvesService(): void
    {
        $container = $this->app->boot();

        $service = $container->get(UserService::class);

        $this->assertInstanceOf(UserService::class, $service);
    }
}

mlc
middleware {
    global = [
        "MonkeysLegion\\Http\\Middleware\\SecurityHeadersMiddleware",
        "MonkeysLegion\\Http\\Middleware\\CorsMiddleware",
        "App\\Middleware\\ApiVersionMiddleware"
    ]
}

bash
# Run tests
php vendor/bin/phpunit

# Run with testdox output
php vendor/bin/phpunit --testdox

# Run specific test
php vendor/bin/phpunit --filter=ApplicationTest

# Static analysis (PHPStan Level 9)
php vendor/bin/phpstan analyse

ini
; php.ini recommended settings
opcache.enable=1
opcache.validate_timestamps=0    ; Disable in production
opcache.max_accelerated_files=20000
opcache.memory_consumption=256
opcache.interned_strings_buffer=16
opcache.jit=1255
opcache.jit_buffer_size=128M