Input Manager Bundle Laravel Package

Product Decisions This Supports

• Build vs. Buy: Accelerates development by eliminating the need to build custom input handling, validation, and mapping logic from scratch. Reduces technical debt by leveraging a pre-built solution with extensibility.
• Feature Roadmap:
  • API/Backend Services: Streamline request/response handling for CRUD operations, reducing boilerplate code in controllers.
  • Data Integrity: Enforce validation rules (e.g., Symfony Constraints) and type safety for Doctrine entities, improving robustness.
  • Nested/Multi-Entity Workflows: Simplify complex payloads (e.g., nested objects, collections) for features like hierarchical data (e.g., articles with categories, users with addresses).
  • Legacy System Modernization: Retrofit older systems with structured input handling without rewriting core logic.
• Use Cases:
  • Admin Panels/Dashboards: Validate and map form submissions (e.g., user profiles, settings) to entities.
  • Microservices: Standardize input processing across services to ensure consistency.
  • Third-Party Integrations: Transform external API payloads into domain objects with minimal custom code.
  • Bulk Operations: Handle array inputs (e.g., batch updates) efficiently via InputCollectionInterface.

When to Consider This Package

• Adopt When:
  • Your Laravel/PHP application relies heavily on Doctrine entities or DTOs and requires consistent input validation/mapping.
  • You frequently handle nested or complex JSON payloads (e.g., GraphQL-like structures) and want to avoid manual parsing.
  • Your team prioritizes developer velocity over custom solutions for input transformation.
  • You need type safety (e.g., auto-converting strings to booleans/integers) without manual checks.
  • Symfony Validation is already in use, and you want to extend it with custom logic.
• Look Elsewhere If:
  • Your project uses non-Doctrine ORMs (e.g., Eloquent) and requires deep integration with Laravel’s built-in request handling (e.g., Form Requests).
  • You need real-time validation (e.g., frontend feedback) and prefer client-side frameworks (e.g., Vue/React) over server-side validation.
  • The package’s maturity (low stars, minimal documentation) is a risk for mission-critical systems. Consider alternatives like:
    • API Platform (for auto-generated CRUD APIs).
    • Symfony Serializer + Validator (for lightweight projects).
    • Custom DTO libraries (e.g., spatie/laravel-data) if Laravel-specific features are needed.
  • Your team lacks PHP/Laravel expertise to debug or extend the package.

How to Pitch It (Stakeholders)

For Executives:

"This package cuts development time for input handling by 30–50% for backend services. By standardizing how we validate and map API requests to our database models, we reduce bugs from manual parsing and enforce consistency across teams. For example, a feature like ‘bulk user updates’—which today requires 2–3 days of custom code—could be implemented in hours. It’s a low-risk investment (MIT license) with high ROI for teams managing complex data workflows."

Key Outcomes:

• Faster iteration on features (e.g., admin panels, integrations).
• Fewer production issues from invalid data.
• Scalable architecture for future growth.

For Engineering Teams:

*"This Laravel bundle replaces repetitive code for:

1. Deserializing JSON into objects (handles camel/snake case, type conversion).
2. Validating inputs (Symfony Constraints + custom rules).
3. Mapping to Doctrine entities (supports nested objects, collections, and entity lookups by ID).

Why Use It?

• Less Boilerplate: No more writing manual json_decode() + foreach loops for complex payloads.
• Extensible: Add custom validation/modifiers via interfaces (e.g., InputModifiableInterface).
• Doctrine-Friendly: Automatically fetches entities by ID (e.g., #[EntityFromId(User::class)]).
• Testable: Isolated input logic makes unit testing easier.

Example Win:

// Before: 15+ lines of manual parsing/validation
// After: 3 lines + a reusable Input class
$input = $this->inputManager->deserialize($request->json(), UserInput::class);
$errors = $this->inputManager->validate($input); // Uses Symfony Constraints
$user = $this->mapper->map($input, User::class);   // Auto-saves to DB

Trade-offs:

• Early-stage package (low stars), but MIT license mitigates risk.
• Requires buy-in to adopt InputInterface pattern for new features.
• Overkill for simple APIs (e.g., single-table CRUD)."*

Next Steps:

• Prototype with a high-priority endpoint (e.g., user registration).
• Compare performance vs. custom solutions (benchmarks).
• Align with existing validation tools (e.g., Symfony Validator).