PHP code example of elarion / elarionstack

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

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

    

elarion / elarionstack example snippets

// PSR-11 compliant with automatic dependency resolution
$container->bind(UserRepository::class, DatabaseUserRepository::class);
$container->singleton(Logger::class, FileLogger::class);

// Auto-wiring with type hints
$service = $container->make(UserService::class);

class DatabaseServiceProvider extends ServiceProvider
{
    public function register(): void
    {
        $this->container->singleton(ConnectionManager::class, function($c) {
            return new ConnectionManager($c->make(Config::class));
        });
    }

    public function boot(): void
    {
        // Bootstrap logic after all services registered
    }
}

use Elarion\Routing\Router;

// Simple routing
$router->get('/users', [UserController::class, 'index']);
$router->post('/users', [UserController::class, 'store']);

// Route parameters with constraints
$router->get('/users/{id}', [UserController::class, 'show'])
    ->where('id', '[0-9]+')
    ->name('users.show');

// Route groups
$router->group(['prefix' => '/api/v1', 'middleware' => ['auth']], function($router) {
    $router->get('/profile', [ProfileController::class, 'show']);
    $router->resource('/posts', PostController::class);
});

use Elarion\Http\Message\{Response, ServerRequest};

// Fluent response creation
return Response::json(['message' => 'Success'], 201)
    ->withHeader('X-Custom', 'Value');

return Response::html('<h1>Hello</h1>');
return Response::redirect('/login');
return Response::noContent();

// Rich request interface
$body = $request->getParsedBody();
$query = $request->getQueryParams();
$header = $request->getHeaderLine('Authorization');

// FIFO middleware execution
$pipeline = new Pipeline();
$response = $pipeline
    ->pipe(new CorsMiddleware())
    ->pipe(new AuthMiddleware())
    ->pipe(new RateLimitMiddleware())
    ->process($request, $handler);

// Short-circuit support
class AuthMiddleware implements MiddlewareInterface
{
    public function process(Request $request, Handler $handler): Response
    {
        if (!$this->isAuthenticated($request)) {
            return Response::json(['error' => 'Unauthorized'], 401);
        }
        return $handler->handle($request);
    }
}

use Elarion\Database\ConnectionManager;

// Multiple named connections
$manager = new ConnectionManager($config);
$mysql = $manager->connection('mysql');
$postgres = $manager->connection('postgres');

// Lazy-loading with automatic reconnection

use Elarion\Database\DB;

// Fluent interface
$users = DB::table('users')
    ->select('id', 'name', 'email')
    ->where('status', '=', 'active')
    ->where('age', '>', 18)
    ->orderBy('created_at', 'desc')
    ->limit(10)
    ->get();

// Complex queries
$results = DB::table('orders')
    ->join('users', 'orders.user_id', '=', 'users.id')
    ->whereIn('status', ['pending', 'processing'])
    ->orWhere(function($query) {
        $query->where('priority', 'high')
              ->where('urgent', true);
    })
    ->groupBy('user_id')
    ->having('total', '>', 1000)
    ->get();

// Aggregates
$count = DB::table('users')->count();
$avg = DB::table('orders')->avg('total');
$sum = DB::table('sales')->sum('amount');

use Elarion\Database\Model;

class User extends Model
{
    protected string $table = 'users';
    protected array $fillable = ['name', 'email', 'age'];
    protected bool $timestamps = true;
}

// CRUD operations
$user = User::create([
    'name' => 'John Doe',
    'email' => '[email protected]',
]);

$user = User::find(1);
$users = User::where('active', true)->get();

$user->update(['name' => 'Jane Doe']);
$user->delete();

// Mass updates
User::where('inactive', true)->update(['status' => 'archived']);

use Elarion\Http\Resources\JsonResource;

class UserResource extends JsonResource
{
    public function toArray(ServerRequestInterface $request): array
    {
        return [
            'id' => $this->id,
            'name' => $this->name,
            'email' => $this->email,

            // Conditional attributes
            'role' => $this->when($this->isAdmin(), $this->role),
            'permissions' => $this->when($this->isAdmin(), $this->permissions),

            // Nested resources
            'posts' => PostResource::collection($this->posts),

            // Merge conditional arrays
            'metadata' => $this->mergeWhen(isset($this->metadata), [
                'last_login' => $this->last_login,
                'created_at' => $this->created_at,
            ]),
        ];
    }
}

// Usage in controllers
return UserResource::make($user)->toResponse($request);
return UserResource::collection($users)->toResponse($request);

use Elarion\Http\Resources\JsonApi\JsonApiResource;

class UserJsonApiResource extends JsonApiResource
{
    public function type(): string
    {
        return 'users';
    }

    public function attributes(ServerRequestInterface $request): array
    {
        return [
            'name' => $this->resource->name,
            'email' => $this->resource->email,
        ];
    }

    public function relationships(ServerRequestInterface $request): array
    {
        return [
            'posts' => $this->relationship(
                'posts',
                PostJsonApiResource::collection($this->resource->posts)
            ),
        ];
    }
}

// Automatic JSON:API formatting with compound documents
return UserJsonApiResource::make($user)->toResponse($request);

use Elarion\Validation\Validator;

$validator = new Validator($request->getParsedBody(), [
    'name' => '' => 'array',
    'is_active' => 'boolean',

    // Nested validation with dot notation
    'address.street' => 'n Response::json([
        'errors' => $validator->errors()
    ], 422);
}

$data = $validator->validated();

// Closure-based
$validator->addRule('username', function($value) {
    return preg_match('/^[a-zA-Z0-9_]+$/', $value);
}, 'Username must be alphanumeric');

// Class-based
class UniqueEmailRule implements RuleInterface
{
    public function passes(string $field, mixed $value, array $data): bool
    {
        return !User::where('email', $value)->exists();
    }

    public function message(string $field): string
    {
        return "The {$field} is already taken.";
    }
}

use Elarion\Support\Collection;

$collection = collect([1, 2, 3, 4, 5]);

// Transformations
$mapped = $collection->map(fn($n) => $n * 2);
$filtered = $collection->filter(fn($n) => $n > 2);
$reduced = $collection->reduce(fn($carry, $n) => $carry + $n, 0);

// Utilities
$sum = $collection->sum();
$avg = $collection->avg();
$first = $collection->first();
$last = $collection->last();

// Sorting & grouping
$sorted = $collection->sort();
$sortedBy = $collection->sortBy('name');
$grouped = $collection->groupBy('category');

// Working with nested data
$users = collect([
    ['name' => 'John', 'email' => '[email protected]'],
    ['name' => 'Jane', 'email' => '[email protected]'],
]);

$emails = $users->pluck('email');
$names = $users->pluck('name')->implode(', ');

// Method chaining
$result = collect($data)
    ->filter(fn($item) => $item['active'])
    ->map(fn($item) => $item['value'])
    ->sum();

use Elarion\OpenAPI\Attributes\{Get, Post, PathParameter, QueryParameter, RequestBody};

class UserController
{
    #[Get(
        path: '/api/users',
        summary: 'List all users',
        description: 'Returns paginated list of users',
        tags: ['Users']
    )]
    #[QueryParameter('page', 'integer', 'Page number')]
    #[QueryParameter('limit', 'integer', 'Items per page')]
    public function index(ServerRequestInterface $request): Response
    {
        // Automatically generates OpenAPI documentation
    }

    #[Post(
        path: '/api/users',
        summary: 'Create new user',
        tags: ['Users']
    )]
    #[RequestBody('User data', 

// Environment variables with type conversion
$debug = env('APP_DEBUG', false); // bool
$port = env('APP_PORT', 8000); // int

// Configuration with dot notation
$dbHost = config('database.connections.mysql.host');

// Debugging
dd($data); // dump and die
dump($data); // dump without stopping

// Response helpers
return response()->json(['status' => 'ok']);
return response()->redirect('/home');

// Collections
$collection = collect([1, 2, 3]);

// Value utilities
$value = value(fn() => expensiveComputation());
$result = tap($user, fn($u) => $u->notify());

// config/database.php
return [
    'default' => env('DB_CONNECTION', 'mysql'),
    'connections' => [
        'mysql' => [
            'driver' => 'mysql',
            'host' => env('DB_HOST', 'localhost'),
            'database' => env('DB_DATABASE', 'app'),
            'username' => env('DB_USERNAME', 'root'),
            'password' => env('DB_PASSWORD', ''),
        ],
    ],
];

// Access anywhere
$connection = config('database.default');
$host = config('database.connections.mysql.host');

use Elarion\Routing\Router;
use Elarion\Http\Message\Response;

$router->get('/api/status', function($request) {
    return Response::json([
        'status' => 'running',
        'framework' => 'ElarionStack',
        'version' => '1.0.0'
    ]);
});

$router->group(['prefix' => '/api/posts'], function($router) {
    $router->get('/', [PostController::class, 'index']);      // GET /api/posts
    $router->post('/', [PostController::class, 'store']);     // POST /api/posts
    $router->get('/{id}', [PostController::class, 'show']);   // GET /api/posts/1
    $router->put('/{id}', [PostController::class, 'update']); // PUT /api/posts/1
    $router->delete('/{id}', [PostController::class, 'destroy']); // DELETE /api/posts/1
});

namespace App\Http\Controllers;

use Elarion\Http\Message\Response;
use Elarion\Validation\Validator;
use Psr\Http\Message\ServerRequestInterface;

class PostController
{
    private array $posts = []; // In-memory storage for demo

    public function index(ServerRequestInterface $request): Response
    {
        return Response::json([
            'data' => $this->posts,
            'total' => count($this->posts)
        ]);
    }

    public function store(ServerRequestInterface $request): Response
    {
        // Validate input
        $validator = new Validator($request->getParsedBody(), [
            'title' => ' ];

        $this->posts[] = $post;

        return Response::json($post, 201);
    }

    public function show(int $id): Response
    {
        $post = $this->findPost($id);

        if (!$post) {
            return Response::json(['error' => 'Post not found'], 404);
        }

        return Response::json($post);
    }

    public function update(int $id, ServerRequestInterface $request): Response
    {
        $post = $this->findPost($id);

        if (!$post) {
            return Response::json(['error' => 'Post not found'], 404);
        }

        $validator = new Validator($request->getParsedBody(), [
            'title' => 'string|min:3|max:255',
            'content' => 'string|min:10',
        ]);

        if (!$validator->validate()) {
            return Response::json([
                'error' => 'Validation failed',
                'details' => $validator->errors()
            ], 422);
        }

        $updated = array_merge($post, $validator->validated());
        $updated['updated_at'] = date('Y-m-d H:i:s');

        return Response::json($updated);
    }

    public function destroy(int $id): Response
    {
        $post = $this->findPost($id);

        if (!$post) {
            return Response::json(['error' => 'Post not found'], 404);
        }

        // Delete post (demo)
        return Response::noContent();
    }

    private function findPost(int $id): ?array
    {
        foreach ($this->posts as $post) {
            if ($post['id'] === $id) {
                return $post;
            }
        }
        return null;
    }
}

// routes/api.php
use Elarion\Routing\Router;
use Elarion\Http\Message\Response;

$router->get('/hello', function($request) {
    return Response::json([
        'message' => 'Hello, ElarionStack!',
        'version' => '1.0.0',
        'timestamp' => date('c')
    ]);
});

$router->get('/users/{id}', [UserController::class, 'show'])
    ->where('id', '[0-9]+')
    ->name('users.show');

// app/Http/Controllers/UserController.php
namespace App\Http\Controllers;

use Elarion\Http\Message\Response;
use Elarion\Validation\Validator;
use Psr\Http\Message\ServerRequestInterface;

class UserController
{
    public function index(ServerRequestInterface $request): Response
    {
        $users = User::all();
        return UserResource::collection($users)->toResponse($request);
    }

    public function store(ServerRequestInterface $request): Response
    {
        $validator = new Validator($request->getParsedBody(), [
            'name' => '
}

// app/Models/User.php
namespace App\Models;

use Elarion\Database\Model;

class User extends Model
{
    protected string $table = 'users';

    protected array $fillable = [
        'name',
        'email',
        'password',
    ];

    protected bool $timestamps = true;
}

// app/Http/Resources/UserResource.php
namespace App\Http\Resources;

use Elarion\Http\Resources\JsonResource;

class UserResource extends JsonResource
{
    public function toArray(ServerRequestInterface $request): array
    {
        return [
            'id' => $this->id,
            'name' => $this->name,
            'email' => $this->email,
            'created_at' => $this->created_at,
        ];
    }
}

// routes/api.php
$router->group(['prefix' => '/api/v1'], function($router) {

    // Public routes
    $router->post('/register', [AuthController::class, 'register']);
    $router->post('/login', [AuthController::class, 'login']);

    // Protected routes
    $router->group(['middleware' => ['auth:api']], function($router) {

        // User profile
        $router->get('/profile', [ProfileController::class, 'show']);
        $router->put('/profile', [ProfileController::class, 'update']);

        // Posts resource
        $router->get('/posts', [PostController::class, 'index']);
        $router->post('/posts', [PostController::class, 'store']);
        $router->get('/posts/{id}', [PostController::class, 'show']);
        $router->put('/posts/{id}', [PostController::class, 'update']);
        $router->delete('/posts/{id}', [PostController::class, 'destroy']);

        // Comments
        $router->post('/posts/{postId}/comments', [CommentController::class, 'store']);
        $router->get('/posts/{postId}/comments', [CommentController::class, 'index']);
    });
});

// Full JSON:API resource with relationships
class PostJsonApiResource extends JsonApiResource
{
    public function type(): string
    {
        return 'posts';
    }

    public function attributes(ServerRequestInterface $request): array
    {
        return [
            'title' => $this->resource->title,
            'content' => $this->resource->content,
            'published_at' => $this->resource->published_at,
        ];
    }

    public function relationships(ServerRequestInterface $request): array
    {
        return [
            'author' => $this->relationship(
                'users',
                UserJsonApiResource::make($this->resource->author),
                links: [
                    'self' => "/api/posts/{$this->id()}/relationships/author",
                    'related' => "/api/posts/{$this->id()}/author",
                ]
            ),
            'comments' => $this->relationship(
                'comments',
                CommentJsonApiResource::collection($this->resource->comments),
                meta: ['count' => count($this->resource->comments)]
            ),
        ];
    }

    public function links(ServerRequestInterface $request): array
    {
        return [
            'self' => "/api/posts/{$this->id()}",
        ];
    }
}

// Controller
public function show(int $id, ServerRequestInterface $request): Response
{
    $post = Post::with(['author', 'comments'])->find($id);

    if (!$post) {
        return JsonApiErrorResponse::notFound('Post not found');
    }

    return PostJsonApiResource::make($post)
        ->toResponse($request);
}

// Advanced queries
$orders = DB::table('orders')
    ->select('orders.*', 'users.name as user_name')
    ->join('users', 'orders.user_id', '=', 'users.id')
    ->leftJoin('shipping', 'orders.id', '=', 'shipping.order_id')
    ->where('orders.status', '=', 'pending')
    ->where(function($query) {
        $query->where('orders.priority', 'high')
              ->orWhere('orders.amount', '>', 1000);
    })
    ->whereIn('orders.payment_method', ['credit_card', 'paypal'])
    ->whereNotNull('shipping.tracking_number')
    ->whereBetween('orders.created_at', ['2024-01-01', '2024-12-31'])
    ->groupBy('orders.user_id')
    ->having('total_amount', '>', 5000)
    ->orderBy('orders.created_at', 'desc')
    ->limit(50)
    ->offset(0)
    ->get();

// Aggregates
$stats = [
    'total_orders' => DB::table('orders')->count(),
    'total_revenue' => DB::table('orders')->sum('amount'),
    'avg_order_value' => DB::table('orders')->avg('amount'),
    'max_order' => DB::table('orders')->max('amount'),
    'min_order' => DB::table('orders')->min('amount'),
];

// Raw queries with bindings
$users = DB::table('users')
    ->whereRaw('YEAR(created_at) = ?', [2024])
    ->get();