Http Factory Laravel Package

Product Decisions This Supports

• API/HTTP Layer Standardization: Enables consistent HTTP client implementation across microservices, APIs, or legacy systems by abstracting client creation (e.g., Guzzle, Symfony HTTP Client) behind a PSR-17 compliant interface. Reduces vendor lock-in and simplifies future migrations.
• Decoupling & Testability: Facilitates dependency injection (DI) and mocking for HTTP clients in unit/integration tests, accelerating development cycles for features requiring HTTP calls (e.g., third-party integrations, webhooks).
• Performance Optimization: Lightweight (~1KB) alternative to monolithic HTTP libraries, ideal for high-throughput systems (e.g., serverless functions, CLI tools) where overhead matters.
• Roadmap for Modularity: Supports a "build vs. buy" strategy—start with this package for core HTTP needs, then extend with custom factories (e.g., for GraphQL, gRPC) as requirements evolve.
• Use Cases:
  • Legacy System Modernization: Wrap outdated curl or custom HTTP logic into PSR-17 factories for gradual refactoring.
  • Multi-Client Environments: Dynamically switch between clients (e.g., Guzzle for production, Mock for tests) without code changes.
  • Edge/Serverless: Reduce cold-start latency by minimizing HTTP client initialization time.

When to Consider This Package

• Adopt When:
  • Your stack already uses PSR-17 (or you’re willing to adopt it) for HTTP factories/messages.
  • You need minimal boilerplate for HTTP client creation (e.g., avoiding manual new Guzzle() calls).
  • Your team prioritizes testability and DI compatibility over built-in features (e.g., retries, middleware).
  • You’re building modular components (e.g., plugins, SDKs) where HTTP clients should be pluggable.
• Look Elsewhere If:
  • You require built-in retries/circuit breakers: Use Symfony HTTP Client or Guzzle’s middleware.
  • Your project needs GraphQL/gRPC support: Consider specialized clients (e.g., webonyx/graphql-php, grpc/grpc).
  • You’re constrained by low PHP version support (requires PHP 7.4+; check your legacy systems).
  • You need advanced observability (e.g., OpenTelemetry): Pair with a dedicated HTTP client or middleware.

How to Pitch It (Stakeholders)

For Executives: "This package lets us standardize how our services make HTTP calls—like using a universal adapter for all our ‘network plugs.’ It’s lightweight, open-source (MIT-licensed), and future-proofs our APIs against vendor changes. For example, if we switch from Guzzle to Symfony’s HTTP client tomorrow, our code only needs a config tweak. It also speeds up development by making HTTP calls easier to mock for tests, which saves QA time. Think of it as insurance for our API layer."

For Engineering: *"tuupola/http-factory gives us PSR-17 HTTP factories with zero config for Guzzle/Symfony clients. Key wins:

• Autodiscovery: No manual client instantiation—just define a factory in config/http.php.
• Testability: Swap real clients for mocks in tests with a single line (e.g., HttpFactory::createMock()).
• Performance: ~1KB footprint; ideal for CLI tools or serverless.
• Extensible: Add custom factories (e.g., for GraphQL) without forking. Use case: Replace hardcoded new Guzzle() calls in our payment service with HttpFactory::createClient(), then mock it in CI. Downstream teams can adopt the same pattern for consistency."*