Weave Code
Property Info Laravel Package
symfony/property-info
Symfony PropertyInfo extracts metadata about PHP class properties (types, visibility, accessors) from multiple sources like reflection, PHPDoc, and serializers. Useful for building API docs, forms, validation, and other tooling that needs reliable property details.
Extracts information about PHP class' properties using metadata of popular sources
Frequently asked questions about Property Info
- How can I use symfony/property-info in Laravel for API request validation?
- Integrate PropertyInfo with Laravel’s validation pipeline by creating a custom validator or middleware. Use the `PropertyInfoExtractorInterface` to fetch property types from your request DTOs or models, then validate incoming data against these types. For example, extract `@var string $email` from PHPDoc and enforce it via Laravel’s `Validator::make()`. Pair with `symfony/property-access` for dynamic property handling.
- What Laravel versions and PHP versions does symfony/property-info support?
- The package requires **PHP 8.1+** (Laravel 10+) or **PHP 8.4+** (Symfony 8+). For Laravel 9 (PHP 8.0), use `symfony/property-info:5.4` with `phpdocumentor/reflection-docblock:^5.0`. Test thoroughly—some features (e.g., union types) may behave differently across PHP versions. Check the [Symfony docs](https://symfony.com/doc/current/components/property_info.html) for version-specific quirks.
- Can symfony/property-info replace Laravel’s built-in `fillable`/`guarded` for dynamic property access?
- Yes, but with caveats. PropertyInfo can infer `fillable` attributes from PHPDoc (e.g., `@property-write`) or reflection, reducing manual configuration. However, it won’t replace Laravel’s magic methods entirely—use it alongside `fillable` for hybrid approaches. For Eloquent, extend the model’s `fillable` logic with PropertyInfo to dynamically allow/disallow fields based on runtime metadata.
- How do I cache PropertyInfo results to avoid reflection overhead in Laravel?
- Leverage Symfony’s built-in caching: configure a `PropertyInfoExtractorInterface` implementation (e.g., `CachedPropertyInfoExtractor`) with a PSR-16 cache (like `symfony/cache`). In Laravel, bind the cached extractor to the container in a service provider. For high-traffic APIs, pre-warm the cache during boot or use Laravel’s `booted` event to lazy-load metadata for critical classes.
- Will symfony/property-info work with Spatie’s Laravel Arrayable or Fractal for API serialization?
- Absolutely. Use PropertyInfo to dynamically infer property types for serialization. For example, annotate your Arrayable models with PHPDoc (e.g., `@property string $name`) and let PropertyInfo validate or transform data during serialization. Integrate with Fractal’s `DataTransformer` to resolve nested property types at runtime, reducing manual type declarations in transformers.
- How do I handle conflicts with phpdocumentor/reflection-docblock v6+ in Laravel?
- Pin `phpdocumentor/reflection-docblock` to `^5.0` in `composer.json` if using Laravel <10. For Laravel 10+, test `^6.0` but watch for issues like [#63206](https://github.com/symfony/symfony/issues/63206). If conflicts persist, fork the package or use a custom `PropertyInfoExtractor` that bypasses docblock parsing for problematic classes. Monitor Symfony’s issue tracker for resolutions.
- Can I use PropertyInfo to generate API documentation (e.g., OpenAPI) for Laravel APIs?
- Yes, PropertyInfo extracts PHPDoc annotations (e.g., `@var`, `@property`) to generate OpenAPI schemas. Integrate with tools like `zircote/swagger-php` or `darkaonline/l5-swagger` to auto-generate docs from your Laravel controllers/models. For example, extract `@property int $id` and map it to OpenAPI’s `integer` type. Combine with `symfony/serializer` for complex nested structures.
- How does PropertyInfo handle Laravel’s magic methods (e.g., `__get`, `__set`, Arrayable traits)?
- PropertyInfo may misclassify magic methods as properties (e.g., `getName()` vs. `$name`). To mitigate this, exclude problematic classes from extraction or use a custom `PropertyInfoExtractor` that filters out non-property methods. For Arrayable traits, whitelist known magic properties (e.g., `toArray()`) or extend the extractor to ignore trait methods entirely.
- What are the performance implications of using PropertyInfo in a high-traffic Laravel app?
- Reflection is expensive, but PropertyInfo mitigates this with caching. For hot paths (e.g., API routes), profile with `Xdebug` to identify slow extractions. Pre-load metadata for critical classes in a service provider’s `boot()` method. Avoid runtime extraction in loops—cache results per request or use compile-time tools (e.g., PHPStan) for static analysis.
- Are there Laravel-specific alternatives to symfony/property-info for property metadata?
- For lightweight use cases, consider `rubix/ml` (machine learning-based type inference) or `phpstan/phpstan` (static analysis). For Laravel-specific needs, `spatie/laravel-arrayable` (serialization) or `laravel/ide-helper` (PHPDoc generation) may suffice. However, PropertyInfo’s multi-source approach (reflection + PHPDoc + serializers) is unmatched for dynamic, runtime-aware metadata—ideal for APIs, forms, and validation where static tools fall short.
Weaver
How can I help you explore Laravel packages today?