spatie/data-transfer-objectArchived
Data Transfer Object
This library provides a framework for defining typed, immutable data structures in PHP. It enables developers to construct structured objects from raw input arrays, ensuring consistent data shapes and schema integrity across different layers of an application. By enforcing strict property types and validation rules during instantiation, the library prevents invalid data states and simplifies the handling of complex information.
The project distinguishes itself through its use of attribute-driven metadata, which allows for property renaming, custom validation, and serialization logic directly within class definitions. It supports recursive type casting, automatically transforming nested arrays into defined class instances to maintain deep type safety. Additionally, the library includes utilities for static type exporting, which generates interface files to synchronize backend data structures with frontend type systems.
Beyond core modeling, the library facilitates data manipulation through immutable methods for filtering and extracting subsets of object data. It also supports lazy property evaluation for optimized serialization and provides specialized containers for managing collections of typed objects. These capabilities allow for the replacement of manual data transformation and validation logic with a centralized, schema-based approach.
Features
- Type-Safe Structured Data Frameworks - Provides a framework for defining typed, immutable data structures to replace manual data handling.
- Data Validation - Enforces strict property types and validation rules during instantiation to ensure data integrity.
- Data Type Casting - Transforms raw input arrays into typed objects using built-in conversion logic to ensure data matches expected formats.
- Structural Data Validators - Validates input data against defined class properties and types to ensure consistent object structure throughout the application lifecycle.
- Attribute Metadata Annotations - Uses language-level attributes to define property metadata, validation rules, and serialization behavior directly within class definitions.
- Input Data Validations - Transforms raw input arrays into validated typed objects during the instantiation process.
- Data Transfer Objects - Constructs structured objects from input data to enforce type safety and consistent data shapes across application layers.
- Immutable Data Management - Enforces strict schemas and property immutability to prevent unintended side effects and ensure data consistency.
- Object Casting Frameworks - Automatically transforms nested arrays and input data into typed objects using custom or built-in conversion logic.
- Object Validations - Allows custom validation logic via attributes to ensure business rules are met during object construction.
- Schema-Validated Class Serializers - Enforces schema integrity by validating raw input data against class property definitions and type hints during instantiation.
- Data Validation - Automatically resolves validation rules from property types to validate raw request inputs upon object creation.
- Structured Return Objects - Constructs objects from arrays or named arguments to enforce consistent structure when passing data across application layers.
- Schema Type Synchronization - Generates interface files from backend data structures to synchronize type systems with frontend code.
- Strict Schema Enforcers - Restricts object creation to defined properties by applying strict mode attributes to prevent the inclusion of unexpected data fields.
- Typed Data Collections - Provides specialized collection containers that enforce type validation for lists of structured data objects.
- Static Type Generators - Generates interface files from class definitions to synchronize backend data structures with frontend type systems.
- Type Definition Generators - Includes utilities for exporting backend data object definitions as interface files for frontend type checking.
- Recursive Object Type Transformers - Automatically transforms nested arrays and objects into defined class instances to maintain deep type safety across complex data hierarchies.
- Accessor Type Castings - Applies custom casting logic during object instantiation to transform input data into nested objects or collections.
- Type-Safe Model Definitions - Constructs structured objects from raw input arrays to ensure consistent data shapes and prevent invalid states.
- Immutability Enforcement Utilities - Prevents modification of object properties after initialization to ensure data consistency and avoid unintended side effects.
- Immutable Data Patterns - Implements immutable object patterns to ensure data consistency and prevent unintended side effects throughout the application lifecycle.
- Nested Object Hierarchies - Converts nested arrays or objects into defined data transfer objects to maintain deep type safety throughout complex hierarchies.
- Nested Object Serializers - Supports recursive type casting to convert nested arrays into defined class instances for deep type safety.
- Type-Safe Frontend Integrations - Exports backend data definitions as interface files to ensure consistent type checking between server and client code.
