Http Pool Bundle Laravel Package

Product Decisions This Supports

• Concurrent API Orchestration: Enables parallel execution of multiple HTTP requests (e.g., fetching user data + orders + payments in a single operation) without manual stream() boilerplate. Reduces latency in composite workflows (e.g., checkout flows, dashboard loads).
• Rate-Limited API Integration: Safeguards against throttling when interacting with third-party APIs (e.g., Stripe, Shopify, or internal microservices with quotas). Avoids 429 Too Many Requests errors and retries intelligently.
• Reactive Fan-Out Patterns: Supports dynamic request chaining (e.g., fetching a user → triggering order history → triggering invoice details). Ideal for:
  • Data Aggregation: Combining disparate API responses (e.g., e-commerce product + reviews + inventory).
  • Event-Driven Workflows: Processing responses to spawn follow-up requests (e.g., webhooks triggering dependent API calls).
• Error Resilience: Provides granular error handling (per-request catch, global strategies) to build robust systems. Use cases:
  • Fallback Mechanisms: Automatically retry or switch to backup APIs if primary fails (e.g., catch to route to a secondary payment processor).
  • Graceful Degradation: Collect errors without crashing (e.g., ErrorStrategy::Collect) for analytics dashboards where partial data is acceptable.
• Build vs. Buy: Replaces custom concurrency logic (e.g., ReactPHP, Guzzle pools) or third-party libraries (e.g., Symfony Panther) with a Symfony-native solution. Reduces technical debt by avoiding ad-hoc implementations.
• Performance Optimization: Bounded concurrency (e.g., concurrency: 10) prevents resource exhaustion while maximizing throughput. Critical for:
  • Bulk Operations: Processing large datasets (e.g., importing 1000+ records via parallel API calls).
  • Background Jobs: Offloading HTTP workloads from synchronous request handlers (e.g., via fire-and-forget).

When to Consider This Package

• Avoid if:
  • You only need single HTTP requests: Use Symfony’s built-in HttpClientInterface directly.
  • Your stack is non-Symfony: This bundle is tightly coupled to Symfony’s DI and HTTP client.
  • You require low-level control: For custom async logic (e.g., WebSockets, raw TCP), use ReactPHP or Amp instead.
  • You’re on PHP < 8.3 or Symfony < 6.4: Compatibility is strict.
• Consider alternatives if:
  • You need serverless/async queues: Use Symfony Messenger + Doctrine Messenger for decoupled processing.
  • You require WebSocket support: Libraries like Ratchet or ReactPHP are better suited.
  • You’re already using GraphQL: Tools like OverblogGraphQLBundle may handle nested data fetching more elegantly.
  • You need advanced observability: Pair with Symfony Profiler + OpenTelemetry for distributed tracing of fan-out chains.

How to Pitch It (Stakeholders)

For Executives/Business Leaders

"This package lets us fetch data from multiple APIs faster and more reliably—like ordering coffee and a pastry at the same time instead of waiting for each one separately. For example:

• Checkout flows: Load user data, payment status, and shipping info in parallel, reducing page load time by 30–50%.
• Analytics dashboards: Aggregate data from Salesforce, Stripe, and our CRM without hitting API limits or crashing.
• Resilience: If one API fails (e.g., a third-party payment processor), we automatically retry or fall back to a backup, keeping the user experience smooth. It’s a drop-in solution that cuts development time and improves performance—no need to reinvent the wheel with custom async code."

For Engineers/Architects

"This bundle solves the ‘how do I call 5 APIs concurrently in Symfony without spaghetti code?’ problem. Key wins:

• Fluent API: Replace verbose stream() loops with clean, chainable methods (add(), then(), catch()).
• Built-in safeguards: Rate limiting, retries with backoff, and deduplication reduce flaky API issues.
• Symfony-native: Integrates seamlessly with DI, HTTP clients, and the profiler—no external dependencies.
• Flexible error handling: Choose between collecting errors, stopping on first failure, or throwing aggregates. Use cases:
• Data pipelines: Fetch and merge responses from multiple sources (e.g., product data + reviews + inventory).
• Event-driven workflows: Trigger follow-up requests based on responses (e.g., webhook → process order → generate invoice).
• Background tasks: Offload HTTP work with fire-and-forget (e.g., analytics tracking). Downside: Early-stage (0 stars), but the code is clean and the feature set is production-ready for Symfony 6.4+."

For Developers

"If you’ve ever written this nightmare:

$responses = [];
$responses['user'] = $httpClient->request(...);
$responses['orders'] = $httpClient->request(...);
foreach ($httpClient->stream($responses) as $response => $chunk) { ... }

…this bundle lets you replace it with:

$pool->add('user', 'GET', ...)->then(...);
$pool->add('orders', 'GET', ...);
$results = $pool->flush();

Features you’ll love:

• Fan-out: Chain requests dynamically (e.g., fetch user → then fetch their orders).
• Deduplication: Avoid duplicate calls with addOnce() (e.g., multiple products sharing a brand).
• Rate limits: Per-host throttling to avoid 429 errors.
• Retries: Configurable backoff for transient failures.
• Fire-and-forget: Send requests without blocking. Just composer require aubes/http-pool-bundle and start building concurrent workflows like a boss."