Property Info Laravel Package

Technical Evaluation

Architecture Fit

The symfony/property-info package is a low-level, metadata-driven reflection tool designed to extract property information (types, mutability, docblocks, etc.) from PHP classes. It is not a high-level framework but rather a foundational component that aligns well with Laravel’s dependency injection (DI), validation, serialization (e.g., API Platform), and form handling systems.

Key Use Cases in Laravel:

1. Dynamic Property Introspection – Useful for serialization (e.g., JSON:API, GraphQL), validation (e.g., Valiation Rules), and ORM hydration (e.g., Eloquent attribute casting).
2. Type System Enhancement – Complements Laravel’s PHP 8+ typed properties by resolving docblock annotations (e.g., @var, @psalm-type) and constructor/accessor-based types.
3. API/ORM Metadata – Powers API Platform, JMS Serializer, or custom serializers by providing runtime property metadata (e.g., for OpenAPI/Swagger generation).
4. Form/Request Binding – Can dynamically infer request binding rules (e.g., for Illuminate\Http\Request or custom form handlers).

Misalignment Risks:

• Not a replacement for Laravel’s built-in reflection (e.g., ReflectionClass). Useful only for metadata-heavy scenarios.
• Overhead for simple use cases – If the goal is basic property access, Laravel’s native reflection or get_object_vars() may suffice.

Integration Feasibility

Example Integration Scenarios:

1. Dynamic Validation Rules

   use Symfony\Component\PropertyInfo\Extractor\PhpDocExtractor;
   use Symfony\Component\PropertyInfo\PropertyInfoExtractor;
   
   $extractor = new PropertyInfoExtractor([new PhpDocExtractor()], new PropertyTypeExtractor());
   $type = $extractor->getTypes(MyModel::class, 'email');
   // Resolves `@var string|null` → applies `required|string` validation.
   

2. API Response Normalization

   $metadata = $extractor->getProperties(MyModel::class);
   // Generates OpenAPI schema from `@OA\Property` or `@var` annotations.
   

Technical Risk

Critical Questions for TPM:

1. What is the primary use case? (Validation? Serialization? ORM?)
   • If validation: Does Laravel’s existing Validator + Rules suffice, or is dynamic metadata needed?
   • If serialization: Will this replace Arrayable, JsonSerializable, or work alongside them?
2. How will this interact with Laravel’s caching layer?
   • Property metadata should be cached (e.g., via Illuminate\Support\Facades\Cache).
3. What’s the fallback for unsupported cases?
   • Example: If PhpDocExtractor fails, should it degrade to ReflectionExtractor?
4. Will this require custom extractors?
   • Example: Laravel’s attribute casting or accessor methods may need a custom ExtractorInterface implementation.
5. How will this affect runtime performance?
   • Benchmark against native reflection and get_object_vars() for critical paths.

Integration Approach

Stack Fit

Migration Path

1. Phase 1: Proof of Concept (PoC)

   • Implement a custom PropertyInfoServiceProvider to bootstrap the component.
   • Test basic extraction (e.g., resolving @var types for a model).
   • Benchmark against native reflection for critical paths.

2. Phase 2: Core Integration

   • Validation: Extend Illuminate\Validation\Rules\Type to use PropertyInfoExtractor.
   • Serialization: Integrate with Spatie’s JSON:API or API Platform for metadata-driven responses.
   • ORM: Add a PropertyInfoCaster to resolve docblock-based attribute casting.

3. Phase 3: Optimization & Caching

   • Cache metadata using Illuminate\Support\Facades\Cache with a tagging system (e.g., model:MyModel).
   • Lazy-load extractors (e.g., only use PhpStanExtractor if phpstan/extension-installer is present).

4. Phase 4: Edge Case Handling

   • Custom Extractors: Implement ExtractorInterface for Laravel-specific cases (e.g., Eloquent accessors).
   • Fallback Logic: Degrade gracefully if docblock parsing fails (e.g., use ReflectionProperty).

Compatibility

Dependency Graph Conflicts:

• phpdocumentor/reflection-docblock: Symfony 8+ requires v6, but some Laravel packages may use v5. Pin versions explicitly.
• symfony/property-access: Optional but useful for property writing checks (e.g., isWritable()).

Sequencing

1. Start with a Non-Critical Feature
   • Example: Enhance API documentation generation (low risk, high visibility).
2. Prioritize Performance-Sensitive Areas
   • Example: Validation rules (high impact if metadata improves UX).
3. Avoid Breaking Changes
   • Use optional integration (e.g., only enable `PropertyInfo