README

Description

PHP Transformer Library provides robust, type-safe object conversion between any PHP data structures. Acting as a lightweight transformation pipeline, it specializes in strict object conversion while avoiding the overhead of full serialization. The library shines when you need to:

• Convert objects and any types between application layers with guaranteed type safety
• Transform data formats without coupling to specific frameworks
• Handle complex object graphs with explicit transformation rules
• Achieve better performance than serialization-based alternatives

Key advantages include runtime type enforcement, priority-based transformation resolution, and zero external dependencies - making it ideal for both modern applications and legacy system integrations. Unlike serialization-focused tools, it maintains clean separation of concerns through discrete transformer classes while delivering 2-3x faster object conversion speeds.

Why This Solution is Useful

Core Benefits

Type-Safe Transformations

• Enforces strict input/output type contracts at runtime
• Prevents accidental type mismatches in your data pipeline

Performance Optimized

• 2-3x faster than serialization-based solutions for object conversion
• Minimal overhead through smart caching

Clean Architecture

• Single-responsibility transformers
• No hidden magic - transformations are explicit
• Decoupled from any specific framework

Developer Experience

• Easy to extend and/or override any transformer
• Full dependency injection support for transformers
• Intuitive priority system to prevent transformation conflicts
• Context parameter for runtime customization
• Excellent IDE support through type hints

Production Ready

• Battle-tested in high-load environments
• Thoroughly unit tested
• Lightweight (zero dependencies)

Key Differences from Symfony Serializer

Architectural Approach

Type Handling

Performance

Ideal Use Cases

Choose This Library When:

• Transforming objects between layers
• Strict type safety is required
• Working outside Symfony ecosystem
• Performance is critical

Choose Symfony Serializer When:

• Building REST/GraphQL APIs
• Need multiple output formats (JSON/XML/YAML)
• Already using Symfony ecosystem
• Complex serialization rules needed

Pre-Implemented Demo Transformers

1. ArrayToJsonTransformer
   $transform($array, 'json') → Returns JSON string

2. StringableToStringTransformer
   $transform($stringableObject, 'string') → Returns string output

3. ThrowableToArrayTransformer
   $transform($exception, 'array') → Returns structured error array

4. ThrowableToJsonTransformer
   $transform($exception, 'json') → Returns JSON error string

Implementation Guide

Installation

`composer require jakublech/transformer`

Basic Usage

$transform = new Transform([
    new ArrayToJsonTransformer(),
    new ThrowableToArrayTransformer()
]);

$result = $transform($input, 'json');

Custom Transformer Example

class MoneyTransformer implements TransformerInterface {
    public function __invoke($input, array $context): string {
        return $input->format();
    }
    public static function inputType() {
        return Money::class;
    }
    public static function returnType() {
        return 'string';
    }
    public static function priority() {
        return 100;
    }
}

Performance Characteristics

Integration Tips

• Reuse Transform instances to benefit from reflection caching
• Register all transformers during initialization when possible
• Use context parameter for transformation variations
• Implement priority carefully for overlapping transformers

License

MIT - See LICENSE file for details