> ## Documentation Index
> Fetch the complete documentation index at: https://mintlify.com/betoalien/Lyger-PHP-Framework/llms.txt
> Use this file to discover all available pages before exploring further.
# Response
> HTTP response creation and output handling
## Overview
The `Response` class provides a fluent interface for creating and sending HTTP responses with proper status codes, headers, and content formatting.
## Constructor
Create a new Response instance.
```php theme={null}
public function __construct(mixed $content = '', int $statusCode = 200, array $headers = [])
```
Response content (string, array, or any value convertible to string)
HTTP status code
Associative array of HTTP headers
### Example
```php theme={null}
use Lyger\Http\Response;
$response = new Response('Hello World', 200, [
'Content-Type' => 'text/plain'
]);
```
## Static Factory Methods
### json
Create a JSON response.
```php theme={null}
public static function json(mixed $data, int $statusCode = 200): self
```
Data to encode as JSON (typically an array)
HTTP status code
### Returns
Response with Content-Type set to `application/json`
JSON encoding uses `JSON_UNESCAPED_UNICODE` and `JSON_UNESCAPED_SLASHES` flags for clean output.
### Example
```php theme={null}
return Response::json([
'success' => true,
'message' => 'User created'
]);
// Content-Type: application/json
// {"success":true,"message":"User created"}
```
```php theme={null}
return Response::json([
'id' => 123,
'name' => 'John Doe'
], 201);
// 201 Created
```
```php theme={null}
return Response::json([
'user' => [
'id' => 1,
'name' => 'John',
'email' => 'john@example.com'
],
'posts' => [
['id' => 1, 'title' => 'First Post'],
['id' => 2, 'title' => 'Second Post']
]
]);
```
### html
Create an HTML response.
```php theme={null}
public static function html(string $html, int $statusCode = 200): self
```
HTML content
HTTP status code
### Returns
Response with Content-Type set to `text/html`
### Example
```php theme={null}
return Response::html('
Welcome
Welcome to Lyger
The fastest PHP framework
');
```
### text
Create a plain text response.
```php theme={null}
public static function text(string $text, int $statusCode = 200): self
```
Plain text content
HTTP status code
### Returns
Response with Content-Type set to `text/plain`
### Example
```php theme={null}
return Response::text('Plain text response');
// Content-Type: text/plain
return Response::text('Server is healthy', 200);
```
### error
Create an error response with JSON format.
```php theme={null}
public static function error(string $message, int $statusCode = 500): self
```
Error message
HTTP error status code
### Returns
JSON response with error message
### Example
```php theme={null}
return Response::error('User not found', 404);
// {"error":"User not found"}
```
```php theme={null}
return Response::error('Invalid input data', 400);
// {"error":"Invalid input data"}
```
```php theme={null}
return Response::error('Authentication required', 401);
// {"error":"Authentication required"}
```
```php theme={null}
return Response::error('Internal server error', 500);
// {"error":"Internal server error"}
```
## Instance Methods
### send
Send the response to the client (outputs headers and content).
```php theme={null}
public function send(): void
```
### Example
```php theme={null}
$response = Response::json(['status' => 'ok']);
$response->send();
// Outputs HTTP headers and JSON content
```
### setHeader
Set a custom HTTP header.
```php theme={null}
public function setHeader(string $key, string $value): self
```
Header name
Header value
### Returns
Same Response instance for method chaining
### Example
```php theme={null}
return Response::json(['data' => 'value'])
->setHeader('X-API-Version', '1.0')
->setHeader('X-Rate-Limit', '1000');
```
### getHeader
Get a header value from the response.
```php theme={null}
public function getHeader(string $key, ?string $default = null): ?string
```
Header name
Default value if header doesn't exist
### Returns
Header value or default
### Example
```php theme={null}
$response = Response::json(['data' => 'value'])
->setHeader('X-Custom', 'value');
$custom = $response->getHeader('X-Custom'); // "value"
$missing = $response->getHeader('X-Missing', 'default'); // "default"
```
### getStatusCode
Get the HTTP status code.
```php theme={null}
public function getStatusCode(): int
```
### Returns
HTTP status code
### Example
```php theme={null}
$response = Response::json(['data' => 'value'], 201);
$code = $response->getStatusCode(); // 201
```
### getContent
Get the response content as a string.
```php theme={null}
public function getContent(): string
```
### Returns
Response content
### Example
```php theme={null}
$response = Response::json(['name' => 'John']);
$content = $response->getContent();
// '{"name":"John"}'
```
## HTTP Status Codes
Common status codes to use with Response methods:
### Success (2xx)
```php theme={null}
// 200 OK - Standard success response
Response::json(['data' => 'value'], 200);
// 201 Created - Resource successfully created
Response::json(['id' => 123], 201);
// 204 No Content - Success with no response body
Response::text('', 204);
```
### Client Errors (4xx)
```php theme={null}
// 400 Bad Request - Invalid input
Response::error('Invalid request data', 400);
// 401 Unauthorized - Authentication required
Response::error('Authentication required', 401);
// 403 Forbidden - Authenticated but not authorized
Response::error('Access denied', 403);
// 404 Not Found - Resource doesn't exist
Response::error('User not found', 404);
// 422 Unprocessable Entity - Validation failed
Response::error('Validation failed', 422);
```
### Server Errors (5xx)
```php theme={null}
// 500 Internal Server Error - Generic server error
Response::error('Internal server error', 500);
// 503 Service Unavailable - Service temporarily down
Response::error('Service unavailable', 503);
```
## Custom Headers
### CORS Headers
```php theme={null}
return Response::json(['data' => 'value'])
->setHeader('Access-Control-Allow-Origin', '*')
->setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE')
->setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');
```
### Cache Control
```php theme={null}
return Response::json(['data' => 'value'])
->setHeader('Cache-Control', 'public, max-age=3600')
->setHeader('Expires', gmdate('D, d M Y H:i:s', time() + 3600) . ' GMT');
```
### Custom API Headers
```php theme={null}
return Response::json(['users' => $users])
->setHeader('X-Total-Count', (string) count($users))
->setHeader('X-Page', '1')
->setHeader('X-Per-Page', '10');
```
## Response Patterns
### RESTful API Responses
```php theme={null}
use Lyger\Http\Request;
use Lyger\Http\Response;
// List resources
Route::get('/api/users', function(Request $request) {
return Response::json([
'data' => [
['id' => 1, 'name' => 'John'],
['id' => 2, 'name' => 'Jane']
]
]);
});
// Create resource
Route::post('/api/users', function(Request $request) {
$data = $request->all();
return Response::json([
'id' => 123,
'name' => $data['name']
], 201);
});
// Update resource
Route::put('/api/users/{id}', function(Request $request, $id) {
return Response::json([
'id' => $id,
'updated' => true
]);
});
// Delete resource
Route::delete('/api/users/{id}', function(Request $request, $id) {
return Response::text('', 204);
});
```
### Error Handling
```php theme={null}
Route::get('/api/users/{id}', function(Request $request, $id) {
if (!is_numeric($id)) {
return Response::error('Invalid user ID', 400);
}
$user = findUser($id);
if (!$user) {
return Response::error('User not found', 404);
}
return Response::json(['user' => $user]);
});
```
### Conditional Responses
```php theme={null}
Route::get('/api/data', function(Request $request) {
$format = $request->get('format', 'json');
$data = ['name' => 'John', 'age' => 30];
return match($format) {
'json' => Response::json($data),
'text' => Response::text(json_encode($data)),
'html' => Response::html("" . json_encode($data, JSON_PRETTY_PRINT) . "
"),
default => Response::error('Invalid format', 400)
};
});
```
### Paginated Responses
```php theme={null}
Route::get('/api/posts', function(Request $request) {
$page = (int) $request->get('page', 1);
$perPage = 10;
// Fetch posts...
$posts = [];
$total = 100;
return Response::json([
'data' => $posts,
'meta' => [
'current_page' => $page,
'per_page' => $perPage,
'total' => $total,
'last_page' => ceil($total / $perPage)
]
])->setHeader('X-Total-Count', (string) $total);
});
```
## Complete Example
```php theme={null}
use Lyger\Http\Request;
use Lyger\Http\Response;
use Lyger\Routing\Route;
// Homepage
Route::get('/', function(Request $request) {
return Response::html('
Lyger API
Welcome to Lyger API
Visit /api/users for the API
');
});
// API endpoint with validation
Route::post('/api/users', function(Request $request) {
$name = $request->input('name');
$email = $request->input('email');
// Validate input
if (!$name || !$email) {
return Response::error('Name and email are required', 400);
}
if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
return Response::error('Invalid email format', 422);
}
// Check authentication
$apiKey = $request->header('X-API-Key');
if ($apiKey !== 'secret-key') {
return Response::error('Unauthorized', 401);
}
// Create user
$user = [
'id' => rand(1000, 9999),
'name' => $name,
'email' => $email,
'created_at' => date('Y-m-d H:i:s')
];
// Return with custom headers
return Response::json([
'success' => true,
'user' => $user
], 201)
->setHeader('X-API-Version', '1.0')
->setHeader('X-Request-ID', uniqid());
});
// Health check endpoint
Route::get('/health', function(Request $request) {
return Response::json([
'status' => 'healthy',
'timestamp' => time()
])->setHeader('Cache-Control', 'no-cache');
});
// Download endpoint
Route::get('/download', function(Request $request) {
return Response::text('File contents here')
->setHeader('Content-Disposition', 'attachment; filename="data.txt"');
});
```