Weave Code
Type Info Laravel Package
symfony/type-info
Symfony TypeInfo extracts and models PHP type information from reflections and type strings. Resolve scalars, objects, enums, generics, lists, and nullable types via TypeResolver, inspect identifiers and constraints, and stringify types like Collection.
Extracts PHP types information.
Frequently asked questions about Type Info
- How can I use Symfony TypeInfo for Laravel validation (e.g., Illuminate\Validation rules)?
- Integrate TypeInfo with Laravel’s validator by resolving property types dynamically. For example, use `TypeResolver` to check if a field is `Collection<int>` and enforce validation rules like `array|min:1` with custom logic. Hook into `Illuminate\Validation\Validator::validate()` to apply type-aware rules based on resolved types.
- Does this package support Laravel’s Eloquent model property type resolution for dynamic queries?
- Yes. Use `TypeResolver` to inspect Eloquent model properties (e.g., `ReflectionProperty` for `created_at: CarbonInterface`) and generate type-safe queries. For example, resolve `Collection<User>` to filter relationships dynamically or enforce return types in custom accessors.
- What’s the best way to integrate TypeInfo into Laravel’s service container?
- Register `TypeResolver` as a singleton in `AppServiceProvider::boot()` using `app()->singleton()`. Bind it to a facade (e.g., `Type::resolve($reflectionProperty)`) for convenience. Example: `app()->bind('type-resolver', fn() => TypeResolver::create());` with lazy resolution where needed.
- Will this work with Laravel Livewire or Nova for form/type validation?
- Absolutely. Use TypeInfo to validate Livewire property types (e.g., `public $items: array<int, string>`) or Nova resource fields. Resolve types during form submission to enforce constraints dynamically. For Nova, extend `ResourceTool` to inject type-aware validation rules.
- How do I handle performance overhead when resolving types for large Laravel apps?
- Leverage Symfony’s `TypeContextFactory` cache (added in v8.1.0) to avoid redundant parsing. For batch resolution (e.g., all Eloquent model properties), use `TypeResolver::resolveBatch()` or lazy-load resolvers only when needed (e.g., during validation or serialization). Benchmark with `10K+` classes to validate caching.
- Can TypeInfo resolve generics in Laravel collections (e.g., `Collection<int>`) or Spatie\LaravelData?
- Yes. TypeInfo resolves generics like `Collection<T>` where `T` is `int`, `string`, or custom classes. For Spatie\LaravelData, use `TypeResolver` to validate serialized data matches declared types (e.g., `Data::make([...])` with `Collection<User>`). Example: `Type::generic(Type::object(Collection::class), Type::int())->isSatisfiedBy(...).
- How should I handle unresolved types in Laravel (e.g., dynamic properties or legacy code)?
- Fallback to `mixed` for unresolved types or throw `TypeError` with Laravel’s `DebugExceptionHandler`. For dynamic properties (e.g., `__get`), check `ReflectionProperty::isInitialized()` before resolving. Document limitations for legacy code (pre-PHP 7.4) where type hints may be missing.
- Does this package work with Laravel’s testing tools (Pest, Mockery) for type-aware assertions?
- Yes. Use `TypeResolver` in tests to assert resolved types (e.g., `expect($type)->isIdentifiedBy(User::class)`). Mock `ReflectionProperty` with Mockery to simulate type resolution for edge cases like generics or recursive types. Test PHP 8.3+ features (e.g., `array{int, string}`) explicitly.
- Are there alternatives to TypeInfo for Laravel type resolution?
- Alternatives include `phpstan/phpstan` (static analysis) or `webmozart/assert` (runtime assertions). However, TypeInfo is unique for dynamic resolution of complex types (generics, nullables, unions) at runtime, which is critical for Laravel’s evolving type system (e.g., typed collections, enums). It’s also more lightweight than full static analyzers.
- How do I extend TypeInfo for custom Laravel use cases (e.g., domain-specific types or runtime enforcement)?
- Extend `TypeResolver` by implementing custom `TypeResolverInterface` methods or create decorators for Laravel-specific logic (e.g., resolving `CarbonInterface` to `DateTime`). For runtime enforcement, hook into Laravel events (e.g., `ModelCreating`) to validate types against resolved schemas. Use `Type::custom()` for domain-specific types.
Weaver
How can I help you explore Laravel packages today?