Product Decisions This Supports

Developer Velocity: Eliminates repetitive manual mapping code for array-to-object conversions, reducing cognitive load and accelerating feature delivery—especially critical for API-driven products or microservices where data transformation is frequent.
Consistency in API Design: Enforces standardized snake_case ↔ camelCase naming conventions across Laravel applications, aligning with Laravel’s ecosystem (e.g., Eloquent, API Resources) and reducing merge conflicts or inconsistent naming in team contributions.
Build vs. Buy Decision: Justifies avoiding custom hydrator implementations (e.g., manual loops, array_map, or over-engineered solutions) by providing a lightweight, MIT-licensed alternative with minimal dependencies. Ideal for teams prioritizing simplicity over flexibility.
Roadmap for Data-Centric Features:
- API Layer: Streamlines hydration of DTOs for request/response payloads, reducing boilerplate in controllers and API resources.
- ORM Alternatives: Offers a lightweight replacement for Eloquent models in projects using raw SQL or query builders, enabling consistent hydration patterns.
- Legacy System Integration: Bridges older systems (e.g., MySQL json columns or flat arrays) with modern PHP 8.3+ applications without rewriting core logic.
Technical Debt Reduction: Centralizes hydration logic in a reusable package, preventing duplication across services (e.g., monorepos or shared libraries) and making the codebase easier to maintain.
Laravel Ecosystem Alignment: Integrates seamlessly with Laravel’s conventions (e.g., Fillable, Cast traits, API Resources), reducing friction for teams already using Laravel’s tooling.

When to Consider This Package

Adopt If:

Your project requires frequent array-to-object conversions (e.g., API responses, form inputs, database arrays) and manual mapping is creating boilerplate bloat.
You’re using PHP 8.3+ and want to leverage modern features like named arguments and enums for cleaner hydration logic.
Your team prioritizes simplicity and consistency over customization (e.g., startups, MVPs, or internal tools with standardized naming conventions).
You need a drop-in replacement for repetitive hydration code in existing Laravel applications, especially in controllers, services, or DTOs.
Your roadmap includes API-driven features (e.g., GraphQL, REST endpoints) where DTO hydration is a bottleneck.

Avoid If:

Your use case requires complex mapping logic (e.g., nested arrays with custom rules, type juggling, or non-standard property names). Consider alternatives like spatie/array-to-object or league/arrayobject.
Performance is critical in high-throughput systems (e.g., bulk API processing). Reflection overhead may impact latency; benchmark against native array_map or json_decode + manual casting.
Your project uses PHP < 8.3, as the package relies on modern PHP features. Downgrade to v1.0.0 if necessary.
You’re already using Symfony’s PropertyAccess or Doctrine’s Hydrator, which offer more flexibility for advanced scenarios (e.g., circular references, custom strategies).
Your codebase doesn’t need naming convention conversion (e.g., already uses camelCase consistently). The auto-conversion may introduce unnecessary complexity.
You require built-in validation or error handling for missing/malformed properties. Pair with Laravel’s validation (e.g., FormRequest) or extend the hydrator manually.

How to Pitch It (Stakeholders)

For Executives/Business Stakeholders

"This package solves a hidden productivity drain in our PHP/Laravel projects: manually converting arrays (like API responses or database results) into objects. By automating this with a single line of code—replacing pages of repetitive property assignments—we can cut developer time by 20–30% on data-heavy tasks. It’s a low-risk, open-source tool that aligns with our PHP 8.3+ stack and Laravel ecosystem, with no long-term maintenance costs. For example, if we’re building a new API or integrating with a legacy system, this lets our team focus on business logic instead of boilerplate. It’s a clear win for velocity without technical debt."

Key Outcomes:

Faster API development and integrations.
Consistent naming conventions across the codebase.
Reduced technical debt from duplicated hydration logic.

For Engineering/Technical Leads

"Simple Hydrator is a lightweight, reflection-based tool to convert arrays to objects with automatic snake_case ↔ camelCase mapping. Here’s why it’s worth adopting:

Pros:

Zero Boilerplate: Replace manual loops like:

$obj->userName = $array['user_name'];

with:

$hydrator->hydrate($array, User::class);

Laravel-Friendly: Works seamlessly with Eloquent, API Resources, and DTOs.
PHP 8.3 Optimized: Uses modern PHP features for cleaner, faster code.
Extensible: Can subclass for custom logic (e.g., property filtering, type casting).

Use Cases:

Hydrating API responses into DTOs or models.
Converting database arrays (e.g., json columns) to objects.
Standardizing naming conventions in microservices.

Tradeoffs:

Not for complex nested mappings (use spatie/array-to-object if needed).
Reflection adds minor overhead (benchmark for high-throughput systems).

Next Steps:

Add to composer.json as a dev dependency.
Replace 1–2 manual hydrators in the codebase to validate ROI.
Document as a team standard for new projects.

Let’s pilot this in [Project X] to measure impact on developer velocity."

For Developers: "This package does one thing really well: turn arrays into objects with camelCase properties, automatically. No more writing out every property assignment—just pass the array and a class name. It’s perfect for:

API responses (e.g., json_decode($response, true) → User object).
Form data (e.g., $request->all() → CreateUserRequest DTO).
Legacy data (e.g., json columns in MySQL → Eloquent models).

Example:

$data = ['first_name' => 'Alice', 'last_name' => 'Smith'];
$user = (new SimpleHydrator())->hydrate($data, User::class);
// $user->firstName = 'Alice'; // camelCase!

Start small—replace one manual hydrator and see how much cleaner the code gets!"

Simple Hydrator Laravel Package