Property Info Laravel Package

Technical Evaluation

Architecture Fit

The symfony/property-info package is a low-level, metadata-driven component designed to extract runtime property information (types, mutability, visibility, etc.) from PHP classes using multiple sources (e.g., PHPDoc annotations, Reflection, PHPStan, DocBlocks). It is not a high-level framework but rather a foundational tool for:

• Type systems (e.g., validation, serialization, API generation).
• ORM/ODM integrations (e.g., Doctrine, MongoDB).
• Dynamic property inspection (e.g., form builders, DTOs, API clients).
• Static analysis tools (e.g., PHPStan, Psalm).

Key Fit for Laravel/PHP Ecosystem:

1. Complements Laravel’s existing tooling:
   • Works alongside Laravel’s validation, serialization (e.g., spatie/laravel-arrayable).
   • Can enhance Laravel Scout (search), Laravel Nova (admin panel), or API resources.
   • Useful for dynamic form generation (e.g., laravelcollective/html).
2. Fills gaps in native PHP reflection:
   • Handles PHPDoc types (e.g., @var, @property), promoted constructor properties, and union types.
   • Supports inheritance and interfaces better than ReflectionProperty.
3. Interoperability with Symfony components:
   • If using Symfony’s Serializer, Validator, or PropertyAccess, this is a natural fit.
   • Can replace or augment Laravel’s illuminate/support/Traits/HasAttributes for dynamic metadata.

Integration Feasibility

Example Use Cases in Laravel:

1. Dynamic Validation:

   use Symfony\Component\PropertyInfo\Extractor\PhpDocExtractor;
   use Symfony\Component\PropertyInfo\PropertyInfoExtractorInterface;
   
   $extractor = new PhpDocExtractor();
   $propertyType = $extractor->getTypes(MyModel::class, 'attribute');
   Validator::extend('type_match', function ($attr, $value, $params) use ($extractor) {
       $types = $extractor->getTypes(MyModel::class, $attr);
       return in_array(gettype($value), $types, true);
   });
   

2. API Response Filtering:

   $propertyInfo = PropertyInfoExtractorInterface::createExtracted([
       new PhpDocExtractor(),
       new ReflectionExtractor(),
   ]);
   $allowed = array_filter($request->input(), fn($val, $key) =>
       $propertyInfo->hasType(MyModel::class, $key, 'string')
   );
   

3. Form Field Generation:

   $fields = collect(MyModel::class)
       ->getProperties()
       ->mapWithKeys(fn($prop) => [
           $prop->getName() => [
               'type' => $extractor->getTypes(MyModel::class, $prop->getName()),
               'label' => ucfirst($prop->getName()),
           ]
       ]);
   

Technical Risk

Critical Questions for TPM:

1. What is the primary use case? (Validation? Serialization? Form generation?)
   • Impact: Determines which extractors (PhpDoc, Reflection, PhpStan) to prioritize.
2. Will this replace or augment existing Laravel tooling?
   • Example: Could PropertyInfo reduce reliance on getCasts() in Eloquent?
3. How will we handle version conflicts with phpdocumentor/reflection-docblock?
   • Solution: Pin to a compatible version (e.g., ^5.0 for Symfony 7/8).
4. What’s the caching strategy for performance?
   • Options: Symfony’s PropertyInfoExtractorInterface supports caching; Laravel’s Cache facade can wrap it.
5. How will this integrate with Laravel’s service container?
   • Approach: Bind PropertyInfoExtractorInterface as a singleton in AppServiceProvider.

Integration Approach

Stack Fit

Key Synergies:

• Symfony Components: If using symfony/validator, symfony/property-access, or symfony/serializer, this is a native fit.
• Laravel Nova: Auto-generate admin panel fields based on property metadata.
• Laravel Scout: Filter searchable attributes dynamically.

Migration Path

1. Phase 1: Proof of Concept (1-2 weeks)
   • Add symfony/property-info to composer.json (target Symfony 7/8 for Laravel 10+).
   • Implement a single extractor (e.g., PhpDocExtractor) for a critical path (e.g., validation).
   • Test with a non-critical model (e.g., User).
2. Phase 2: Core Integration (2-3 weeks)
   • Replace manual type checks with PropertyInfo in:
     • Validation rules.
     • API resource filtering.
     • Form generation.
   • Add caching (e.g., Cache::remember()) for performance.
3. Phase 3: Full Adoption (Ongoing)
   • Migrate Eloquent getCasts() to dynamic PropertyInfo checks.
   • Integrate with Laravel Nova or API clients for auto-generated metadata.
   • Deprecate legacy type-checking logic.

Backward Compatibility:

• Use feature flags to toggle PropertyInfo usage.
• Provide fallbacks for unsupported PHP versions (e.g., <8.1).

Compatibility