Request Object

ApnaPHP's Request object provides a comprehensive interface for handling HTTP requests. It encapsulates all request data including GET parameters, POST data, files, headers, cookies, and more.

1. Creating a Request Object

The Request object is automatically created and passed to your route handlers:

<?php
// app/api/users/route.apna.php

use ApnaPHP\Routing\Request;
use ApnaPHP\Routing\Response;

function GET(Request $request): Response
{
    // Request object is automatically injected
    $userId = $request->param('id');
    $search = $request->query('search');
    
    return Response::json(['user_id' => $userId, 'search' => $search]);
}

You can also create a Request object manually:

use ApnaPHP\Routing\Request;

$request = Request::createFromGlobals();

2. Request Information

HTTP Method

$method = $request->method(); // GET, POST, PUT, DELETE, etc.
$isGet = $request->isGet();
$isPost = $request->isPost();
$isPut = $request->isPut();
$isDelete = $request->isDelete();
$isPatch = $request->isPatch();

URL Information

$uri = $request->uri(); // Full URI
$path = $request->path(); // Path without query string
$queryString = $request->queryString(); // Query string
$fullUrl = $request->fullUrl(); // Full URL with protocol and host
$url = $request->url(); // URL without query string

Request Headers

$allHeaders = $request->headers(); // All headers as array
$contentType = $request->header('Content-Type');
$userAgent = $request->header('User-Agent');
$authorization = $request->header('Authorization');

// Check if header exists
$hasContentType = $request->hasHeader('Content-Type');

Client Information

$ip = $request->ip(); // Client IP address
$userAgent = $request->userAgent(); // User agent string
$isAjax = $request->isAjax(); // Check if request is AJAX
$isJson = $request->isJson(); // Check if request expects JSON

3. Input Data

GET Parameters

$allQuery = $request->query(); // All GET parameters
$search = $request->query('search'); // Single parameter
$page = $request->query('page', 1); // With default value
$filters = $request->query('filters', []); // Array with default

// Check if parameter exists
$hasSearch = $request->hasQuery('search');

POST Data

$allPost = $request->post(); // All POST data
$name = $request->post('name'); // Single field
$email = $request->post('email', ''); // With default value
$data = $request->post('data', []); // Array with default

// Check if field exists
$hasName = $request->hasPost('name');

All Input Data

$allInput = $request->all(); // All input data (GET + POST)
$name = $request->input('name'); // Single input with default
$email = $request->input('email', ''); // With default value

// Check if input exists
$hasName = $request->hasInput('name');

// Get only specified inputs
$userData = $request->only(['name', 'email', 'password']);
$userData = $request->except(['password', 'password_confirmation']);

JSON Data

$jsonData = $request->json(); // All JSON data
$name = $request->json('name'); // Single JSON field
$email = $request->json('email', ''); // With default value

// Check if JSON data exists
$hasJson = $request->hasJson();

4. Route Parameters

Dynamic Route Parameters

// For route: /api/users/{id}/posts/{postId}
function GET(Request $request): Response
{
    $userId = $request->param('id'); // Get route parameter
    $postId = $request->param('postId'); // Get route parameter
    $allParams = $request->params(); // All route parameters
    
    return Response::json([
        'user_id' => $userId,
        'post_id' => $postId,
        'all_params' => $allParams
    ]);
}

Parameter Validation

$userId = $request->param('id');
if (!$userId || !is_numeric($userId)) {
    return Response::json(['error' => 'Invalid user ID'], 400);
}

5. File Uploads

Single File

$file = $request->file('avatar'); // Get uploaded file
if ($file) {
    $fileName = $file['name'];
    $fileSize = $file['size'];
    $fileType = $file['type'];
    $tempPath = $file['tmp_name'];
}

Multiple Files

$files = $request->files('photos'); // Array of files
foreach ($files as $file) {
    if ($file['error'] === UPLOAD_ERR_OK) {
        // Process file
    }
}

File Validation

$file = $request->file('avatar');
if ($file && $file['error'] === UPLOAD_ERR_OK) {
    // File uploaded successfully
    $isImage = strpos($file['type'], 'image/') === 0;
    $isValidSize = $file['size'] <= 2 * 1024 * 1024; // 2MB
}

6. Cookies

Get Cookies

$allCookies = $request->cookies(); // All cookies
$sessionId = $request->cookie('session_id'); // Single cookie
$theme = $request->cookie('theme', 'light'); // With default value

// Check if cookie exists
$hasSession = $request->hasCookie('session_id');

7. Server Information

Server Variables

$serverInfo = $request->server(); // All server variables
$requestMethod = $request->server('REQUEST_METHOD');
$requestUri = $request->server('REQUEST_URI');
$httpHost = $request->server('HTTP_HOST');

Environment Information

$isHttps = $request->isSecure(); // Check if HTTPS
$isLocalhost = $request->isLocalhost(); // Check if localhost
$host = $request->host(); // Get host
$port = $request->port(); // Get port
$scheme = $request->scheme(); // Get scheme (http/https)

8. Request Validation

Basic Validation

function POST(Request $request): Response
{
    // Validate required fields
    if (!$request->hasInput('name')) {
        return Response::json(['error' => 'Name is required'], 400);
    }
    
    if (!$request->hasInput('email')) {
        return Response::json(['error' => 'Email is required'], 400);
    }
    
    // Get and validate data
    $name = $request->input('name');
    $email = $request->input('email');
    
    if (strlen($name) < 3) {
        return Response::json(['error' => 'Name must be at least 3 characters'], 400);
    }
    
    if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
        return Response::json(['error' => 'Invalid email format'], 400);
    }
    
    // Process data
    return Response::json(['message' => 'User created successfully']);
}

Using Validation Helper

use ApnaPHP\Support\Validation;

function POST(Request $request): Response
{
    try {
        $validated = validate($request->all(), [
            'name' => 'required|min:3|max:255',
            'email' => 'required|email',
            'password' => 'required|min:8|confirmed'
        ]);
        
        // Data is valid
        return Response::json(['message' => 'User created successfully']);
        
    } catch (ValidationException $e) {
        return Response::json(['errors' => $e->errors()], 422);
    }
}

9. Request Transformation

Data Sanitization

function POST(Request $request): Response
{
    $data = $request->all();
    
    // Sanitize input data
    $data['name'] = trim($data['name']);
    $data['email'] = strtolower(trim($data['email']));
    $data['description'] = strip_tags($data['description']);
    
    // Process sanitized data
    return Response::json(['message' => 'Data processed']);
}

Data Filtering

function POST(Request $request): Response
{
    // Get only allowed fields
    $allowedFields = ['name', 'email', 'phone', 'bio'];
    $userData = $request->only($allowedFields);
    
    // Remove sensitive fields
    $safeData = $request->except(['password', 'password_confirmation', 'admin_token']);
    
    return Response::json(['data' => $safeData]);
}

10. API Request Handling

JSON API Requests

function POST(Request $request): Response
{
    // Check if request expects JSON
    if (!$request->isJson()) {
        return Response::json(['error' => 'Content-Type must be application/json'], 415);
    }
    
    // Get JSON data
    $data = $request->json();
    
    if (!$data) {
        return Response::json(['error' => 'Invalid JSON data'], 400);
    }
    
    // Process JSON data
    return Response::json(['message' => 'JSON data processed']);
}

Form Data Requests

function POST(Request $request): Response
{
    // Check if request is form data
    if ($request->isJson()) {
        return Response::json(['error' => 'Form data expected'], 400);
    }
    
    // Get form data
    $data = $request->post();
    
    // Process form data
    return Response::json(['message' => 'Form data processed']);
}

11. File Upload Handling

Single File Upload

function POST(Request $request): Response
{
    $file = $request->file('avatar');
    
    if (!$file) {
        return Response::json(['error' => 'No file uploaded'], 400);
    }
    
    if ($file['error'] !== UPLOAD_ERR_OK) {
        return Response::json(['error' => 'File upload failed'], 400);
    }
    
    // Validate file type
    $allowedTypes = ['image/jpeg', 'image/png', 'image/gif'];
    if (!in_array($file['type'], $allowedTypes)) {
        return Response::json(['error' => 'Invalid file type'], 400);
    }
    
    // Validate file size (2MB)
    if ($file['size'] > 2 * 1024 * 1024) {
        return Response::json(['error' => 'File too large'], 400);
    }
    
    // Process file
    $uploadPath = 'uploads/' . uniqid() . '.' . pathinfo($file['name'], PATHINFO_EXTENSION);
    move_uploaded_file($file['tmp_name'], $uploadPath);
    
    return Response::json(['message' => 'File uploaded successfully', 'path' => $uploadPath]);
}

Multiple File Upload

function POST(Request $request): Response
{
    $files = $request->files('photos');
    
    if (!$files || !is_array($files)) {
        return Response::json(['error' => 'No files uploaded'], 400);
    }
    
    $uploadedFiles = [];
    
    foreach ($files as $file) {
        if ($file['error'] === UPLOAD_ERR_OK) {
            $uploadPath = 'uploads/' . uniqid() . '.' . pathinfo($file['name'], PATHINFO_EXTENSION);
            move_uploaded_file($file['tmp_name'], $uploadPath);
            $uploadedFiles[] = $uploadPath;
        }
    }
    
    return Response::json(['message' => 'Files uploaded successfully', 'files' => $uploadedFiles]);
}

12. Request Middleware

Authentication Middleware

function POST(Request $request): Response
{
    // Check authentication
    $token = $request->header('Authorization');
    if (!$token) {
        return Response::json(['error' => 'Authorization header required'], 401);
    }
    
    // Validate token
    if (!validateToken($token)) {
        return Response::json(['error' => 'Invalid token'], 401);
    }
    
    // Process authenticated request
    return Response::json(['message' => 'Request processed']);
}

Rate Limiting

function POST(Request $request): Response
{
    $ip = $request->ip();
    $rateLimitKey = "rate_limit:{$ip}";
    
    // Check rate limit
    $currentRequests = cache()->get($rateLimitKey, 0);
    if ($currentRequests >= 100) { // 100 requests per hour
        return Response::json(['error' => 'Rate limit exceeded'], 429);
    }
    
    // Increment rate limit counter
    cache()->put($rateLimitKey, $currentRequests + 1, 3600);
    
    // Process request
    return Response::json(['message' => 'Request processed']);
}

13. Best Practices

• Always Validate Input: Never trust user input. Always validate and sanitize data.
• Use Type Hints: Use proper type hints for request parameters.
• Handle Errors Gracefully: Always handle potential errors and provide meaningful error messages.
• Sanitize Data: Sanitize input data to prevent XSS and other security issues.
• Use HTTPS: Always use HTTPS in production to protect sensitive data.
• Implement Rate Limiting: Implement rate limiting to prevent abuse.
• Log Requests: Log important requests for debugging and monitoring.

The Request object provides a comprehensive interface for handling all aspects of HTTP requests in ApnaPHP applications.