Easy Hydrator Laravel Package

Product Decisions This Supports

• Accelerate API/Service Integration: Reduces boilerplate for converting API responses (arrays) into domain objects, speeding up backend development for microservices, CRUD endpoints, or third-party integrations.
• Enforce Type Safety: Aligns with modern PHP 8.0+ practices by leveraging constructor injection and type declarations, reducing runtime errors and improving maintainability.
• Simplify Data Transformation: Eliminates manual mapping logic (e.g., new Person($array['name'], $array['age'])), cutting development time for data pipelines (e.g., ETL, batch processing).
• Roadmap for Value Objects: Supports adoption of immutable value objects (e.g., Person, OrderId) in DDD or clean architecture, reducing coupling between layers.
• Build vs. Buy: Avoids reinventing hydration logic (e.g., custom ArrayToObject utilities) while offering more flexibility than Laravel’s built-in collect() or array_map.
• Use Cases:
  • API Clients: Auto-hydrate JSON responses into typed objects (e.g., Stripe, Shopify).
  • Database Abstraction: Convert raw DB rows (e.g., from Eloquent or Doctrine) into domain models.
  • Event Sourcing: Rehydrate events from storage into strongly typed objects.
  • Legacy Migration: Gradually introduce typed objects in monolithic apps.

When to Consider This Package

• Look Here If:

  • Your team uses PHP 8.0+ and constructor injection for domain objects.
  • You frequently convert arrays/JSON → objects (e.g., API responses, DB rows).
  • You want zero-boilerplate hydration with type safety (e.g., DateTimeInterface auto-conversion).
  • You’re adopting value objects or DDD and need a lightweight solution.
  • You’re willing to trade minor customization (e.g., no fluent interfaces) for simplicity.

• Look Elsewhere If:

  • You need fluent method chaining (e.g., hydrator->setCustomMapper()->hydrate()).
  • Your objects require complex nested hydration (e.g., circular references, custom resolvers).
  • You’re using PHP < 8.0 (no constructor property promotion support).
  • You prioritize performance-critical paths (this package adds minimal overhead but isn’t optimized for bulk operations).
  • You need Symfony-specific features (e.g., deep integration with Doctrine or API Platform).
  • Your team prefers explicit control over hydration (e.g., manual ArrayObject or stdClass mapping).

How to Pitch It (Stakeholders)

For Executives/Business Leaders:

"This package cuts 30–50% of the manual code needed to convert raw data (like API responses or database rows) into structured objects—our domain models. For example, instead of writing 5 lines of code to create a Person object from an array, we’ll do it in one line. This speeds up backend development, reduces bugs from manual mapping, and aligns with modern PHP best practices. It’s a low-risk, high-reward tool to improve developer velocity without adding technical debt."

ROI:

• Faster iteration on APIs/services.
• Fewer runtime errors from type mismatches.
• Easier maintenance for data-heavy features.

For Engineers/Architects:

"easy-hydrator solves a common pain point: converting arrays to typed objects with minimal ceremony. Key benefits:

• Constructor Injection Support: Works seamlessly with PHP 8.0’s typed properties and constructor promotion.
• Auto-Conversion: Handles DateTimeInterface, nested objects, and type hints automatically (e.g., string → string, "2023-01-01" → DateTime).
• Performance: Cached hydrators avoid redundant reflection calls.
• Symfony-Friendly: Integrates with bundles and DI container out of the box.

Use it for:

• API clients (e.g., hydrate($stripeResponse['customer'])).
• Database abstraction (e.g., hydrate($dbRow) → User).
• Event sourcing or CQRS pipelines.

Trade-offs:

• Not for ultra-custom hydration (e.g., dynamic property names).
• Minimal docs (but simple API).

Alternatives: If you need more control, consider spatie/array-to-object or manual mapping—but this is the simplest option for 80% of cases."*

Tech Stack Fit:

• Laravel/Symfony apps using PHP 8.0+.
• Projects adopting value objects or DDD.
• Teams tired of array_key_exists() + new Class(...) spaghetti.