Jms Serializer Bridge Laravel Package

Getting Started

Minimal Setup

1. Installation

   composer require dlakomski/jms-serializer-bridge
   

   Ensure jms/serializer-bundle and simplebus/simple-bus are already installed in your Laravel project.

2. Configuration Add the bridge to your SimpleBus configuration (typically in config/simple_bus.php):

   'serializers' => [
       'jms' => \Dlakomski\JmsSerializerBridge\JmsSerializer::class,
   ],
   

3. First Use Case Serialize a message for async dispatch:

   use Dlakomski\JmsSerializerBridge\JmsSerializer;
   use SimpleBus\Message\Message;
   
   class MyMessage implements Message {
       public string $data;
   }
   
   $serializer = app(JmsSerializer::class);
   $serialized = $serializer->serialize(new MyMessage('test'));
   

Implementation Patterns

Workflow Integration

1. Message Serialization Use the bridge to serialize messages before dispatching via SimpleBus:

   $serializer = app(JmsSerializerBridge\JmsSerializer::class);
   $serialized = $serializer->serialize($message);
   $bus->dispatchAsync($serialized);
   

2. Deserialization Deserialize messages in handlers:

   $deserialized = $serializer->deserialize($serializedData, MyMessage::class);
   

3. Middleware Integration Wrap serialization/deserialization in middleware for consistency:

   $bus->addMiddleware(new class implements Middleware {
       public function handle($message, callable $next) {
           $serializer = app(JmsSerializer::class);
           $serialized = $serializer->serialize($message);
           return $next($serialized);
       }
   });
   

4. Laravel Service Provider Bind the bridge in AppServiceProvider for dependency injection:

   $this->app->bind(JmsSerializer::class, function ($app) {
       return new JmsSerializer($app->make(\JMS\Serializer\SerializerInterface::class));
   });
   

Gotchas and Tips

Pitfalls

1. Circular References JMS Serializer may throw exceptions on circular references. Use @Ignore annotations or handlers:

   use JMS\Serializer\Annotation as Serializer;
   
   class MyMessage {
       #[Serializer\ExclusionPolicy('ALL')]
       public $circularRef;
   }
   

2. Type Safety Ensure deserialized objects match expected classes to avoid runtime errors:

   try {
       $message = $serializer->deserialize($data, MyMessage::class);
   } catch (\JMS\Serializer\Exception\RuntimeException $e) {
       // Handle invalid data
   }
   

3. Configuration Overrides The bridge assumes default JMS Serializer config. Override via config/packages/jms_serializer.yaml if needed:

   handlers:
       MyMessage:
           serialization:
               groups: ['default']
   

Tips

1. Custom Metadata Extend serialization with custom metadata:

   $serializer->setMetadataFactory(new CustomMetadataFactory());
   

2. Performance Cache metadata for repeated serialization:

   $serializer->setMetadataFactory(new CachedMetadataFactory($cache, $originalFactory));
   

3. Testing Mock the bridge in tests:

   $this->mock(JmsSerializer::class)
        ->shouldReceive('serialize')
        ->once()
        ->andReturn('serialized_data');
   

4. Laravel Caching Leverage Laravel’s cache for JMS metadata:

   $metadataFactory = new CachedMetadataFactory(
       Cache::store('array'),
       new Metadata\Driver\FileDriver(__DIR__.'/serializer/metadata')
   );