// Simple GET request $response = fetch('https://api.example.com/users'); $users = $response->json(); // POST request with JSON body $response = fetch('https://api.example.com/users', [ 'method' => 'POST', 'json' => ['name' => 'John Doe', 'email' => 'john@example.com'], ]);

// GET request with query parameters $response = get('https://api.example.com/users', ['page' => 1, 'limit' => 10]); // POST request with JSON data $response = post('https://api.example.com/users', [ 'name' => 'John Doe', 'email' => 'john@example.com' ]);

// Chain methods to build your request $response = fetch_client() ->baseUri('https://api.example.com') ->withHeaders(['Accept' => 'application/json']) ->withToken('your-auth-token') ->withQueryParameters(['page' => 1, 'limit' => 10]) ->get('/users');

// Import async/await functions from Matrix library use function async; use function await; // Wrap your fetch call in an async function $promise = async(function() { return fetch('https://api.example.com/users'); }); // Await the result $response = await($promise); $users = $response->json(); echo "Fetched " . count($users) . " users";

// These async functions are provided by the Matrix library dependency use function async; use function await; use function all; // Execute an async function await(async(function() { // Create multiple requests $results = await(all([ 'users' => async(fn() => fetch('https://api.example.com/users')), 'posts' => async(fn() => fetch('https://api.example.com/posts')), 'comments' => async(fn() => fetch('https://api.example.com/comments')) ])); // Process the results $users = $results['users']->json(); $posts = $results['posts']->json(); $comments = $results['comments']->json(); echo "Fetched " . count($users) . " users, " . count($posts) . " posts, and " . count($comments) . " comments"; }));

use function async; use function await; await(async(function() { // First request: get auth token $authResponse = await(async(fn() => fetch('https://api.example.com/auth/login', [ 'method' => 'POST', 'json' => [ 'username' => 'user', 'password' => 'pass' ] ]) )); $token = $authResponse->json()['token']; // Second request: use token to get user data $userResponse = await(async(fn() => fetch('https://api.example.com/me', [ 'token' => $token ]) )); return $userResponse->json(); }));

use function async; use function await; try { $data = await(async(function() { $response = await(async(fn() => fetch('https://api.example.com/users/999') )); if ($response->isNotFound()) { throw new \Exception("User not found"); } return $response->json(); })); // Process the data } catch (\Exception $e) { echo "Error: " . $e->getMessage(); }

// Set up an async request // Get the handler for async operations $handler = fetch_client()->getHandler(); $handler->async(); // Make the async request $promise = $handler->get('https://api.example.com/users'); // Handle the result with callbacks $promise->then( function ($response) { // Process successful response $users = $response->json(); foreach ($users as $user) { echo $user['name'] . PHP_EOL; } }, function ($exception) { // Handle errors echo "Error: " . $exception->getMessage(); } );

use function race; // Create promises for redundant endpoints $promises = [ async(fn() => fetch('https://api1.example.com/data')), async(fn() => fetch('https://api2.example.com/data')), async(fn() => fetch('https://api3.example.com/data')) ]; // Get the result from whichever completes first $response = await(race($promises)); $data = $response->json(); echo "Got data from the fastest source";

use function map; // List of user IDs to fetch $userIds = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; // Process at most 3 requests at a time $responses = await(map($userIds, function($id) { return async(function() use ($id) { return fetch("https://api.example.com/users/{$id}"); }); }, 3)); // Process the responses foreach ($responses as $index => $response) { $user = $response->json(); echo "Processed user {$user['name']}\n"; }

use function batch; // Array of items to process $items = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; // Process in batches of 3 with max 2 concurrent batches $results = await(batch( $items, function($batch) { // Process a batch return async(function() use ($batch) { $batchResults = []; foreach ($batch as $id) { $response = await(async(fn() => fetch("https://api.example.com/users/{$id}") )); $batchResults[] = $response->json(); } return $batchResults; }); }, 3, // batch size 2 // concurrency ));

use function retry; // Retry a flaky request up to 3 times with exponential backoff $data = await(retry( function() { return async(function() { return fetch('https://api.example.com/unstable-endpoint'); }); }, 3, // max attempts function($attempt) { // Exponential backoff strategy return min(pow(2, $attempt) * 100, 1000); } ));

$response = fetch_client() ->retry(3, 200) // 3 retries, 200ms base delay ->retryStatusCodes([429, 503]) // optional: customize which statuses retry ->get('https://api.example.com/unstable');

// Basic auth $response = fetch('https://api.example.com/secure', [ 'auth' => ['username', 'password'] ]); // Bearer token $response = fetch_client() ->withToken('your-oauth-token') ->get('https://api.example.com/secure');

$response = fetch('https://api.example.com', [ 'proxy' => 'http://proxy.example.com:8080' ]); // Or with fluent API $response = fetch_client() ->withProxy('http://proxy.example.com:8080') ->get('https://api.example.com');

// Configure once at application bootstrap fetch_client([ 'base_uri' => 'https://api.example.com', 'headers' => [ 'User-Agent' => 'MyApp/1.0', 'Accept' => 'application/json', ], 'timeout' => 10, ]); // Use the configured client throughout your application function getUserData($userId) { return fetch_client()->get("/users/{$userId}")->json(); } function createUser($userData) { return fetch_client()->post('/users', $userData)->json(); }

$response = fetch('https://api.example.com/users/1'); // Check if request was successful if ($response->successful()) { // HTTP status code echo $response->getStatusCode(); // 200 // Response body as JSON $user = $response->json(); // Response body as string $body = $response->getBody()->getContents(); // Get a specific header $contentType = $response->getHeaderLine('Content-Type'); // Check status code categories if ($response->statusEnum()->isSuccess()) { echo "Request succeeded"; } }

use Fetch\Enum\Method; use Fetch\Enum\ContentType; use Fetch\Enum\Status; // Use enums for HTTP methods $client = fetch_client(); $response = $client->request(Method::POST, '/users', $userData); // Check HTTP status with enums if ($response->getStatus() === Status::OK) { // Process successful response } // Content type handling $response = $client->withBody($data, ContentType::JSON)->post('/users');

// Synchronous error handling try { $response = fetch('https://api.example.com/nonexistent'); if (!$response->successful()) { echo "Request failed with status: " . $response->getStatusCode(); } } catch (\Throwable $e) { echo "Exception: " . $e->getMessage(); } // Asynchronous error handling $handler = fetch_client()->getHandler(); $handler->async(); $promise = $handler->get('https://api.example.com/nonexistent') ->then(function ($response) { if ($response->successful()) { return $response->json(); } throw new \Exception("Request failed with status: " . $response->getStatusCode()); }) ->catch(function (\Throwable $e) { echo "Error: " . $e->getMessage(); });

$response = fetch('https://api.example.com/data', [ 'timeout' => 15, // total request timeout (seconds) 'connect_timeout' => 5, // connection timeout (seconds) ]);