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.

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)

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

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

`composer require jakublech/transformer`

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

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

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;
    }
}

• 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

MIT - See LICENSE file for details