Sim Xml Bundle Laravel Package

Getting Started

Minimal Setup for Laravel Integration

Since this is a Symfony Flex bundle, Laravel developers will need to adapt it via Symfony Bridge or Laravel Symfony Integration. Start by:

1. Install the Bundle (via Composer):

   composer require common-gateway/sim-xml-bundle:dev-main
   

   (Note: Laravel’s autoloader may require composer dump-autoload afterward.)

2. Enable the Bundle (if using Symfony components): Add to config/bundles.php (Symfony) or manually register in Laravel’s service container via AppServiceProvider:

   // config/bundles.php (Symfony)
   return [
       // ...
       CommonGateway\SimXmlBundle\SimXmlBundle::class => ['all' => true],
   ];
   

3. Run the Installer Command (if entities/schemas are needed):

   php artisan symfony:command commongateway:install common-gateway/sim-xml-bundle
   

   (Laravel may need a custom command wrapper for Symfony commands.)

4. First Use Case: Use the bundle’s XML parsing/validation logic (e.g., SimXmlParser) in a Laravel service:

   use CommonGateway\SimXmlBundle\Parser\SimXmlParser;
   
   $parser = new SimXmlParser();
   $xmlData = $parser->parse(file_get_contents('example.xml'));
   

Implementation Patterns

Workflow: XML Processing in Laravel

1. Dependency Injection: Register the bundle’s services in Laravel’s container (e.g., SimXmlParser) via bind() in AppServiceProvider:

   $this->app->bind(SimXmlParser::class, function ($app) {
       return new SimXmlParser();
   });
   

2. Command Integration: Extend Symfony commands for Laravel’s Artisan:

   use Symfony\Component\Console\Command\Command;
   use CommonGateway\SimXmlBundle\Command\InstallCommand;
   
   class InstallSimXmlCommand extends Command {
       protected function configure() {
           $this->setName('simxml:install');
       }
       protected function execute(InputInterface $input, OutputInterface $output) {
           $installer = new InstallCommand();
           return $installer->run($input, $output);
       }
   }
   

3. Event-Driven XML Handling: Use Laravel events to trigger XML processing (e.g., after file upload):

   event(new XmlFileUploaded($filePath));
   // Listener:
   public function handle(XmlFileUploaded $event) {
       $parser = app(SimXmlParser::class);
       $data = $parser->parse($event->filePath);
   }
   

4. Configuration: Override Symfony’s config/packages/sim_xml.yaml in Laravel’s config/sim_xml.php:

   return [
       'schemas' => [
           'default' => 'path/to/schema.xsd',
       ],
   ];
   

Gotchas and Tips

Pitfalls

1. Symfony vs. Laravel Autoloading:

   • Laravel’s vendor/autoload.php may not auto-load Symfony bundles. Run:

     composer dump-autoload
     

   • If using Docker, ensure autoload is regenerated in the container.

2. Command Namespace Conflicts: Symfony commands (e.g., commongateway:install) may clash with Laravel’s Artisan. Prefix or alias them:

   php artisan symfony:command commongateway:install
   

3. Entity Manager Mismatch: The bundle assumes Doctrine ORM. For Laravel Eloquent, mock the EntityManager or adapt the bundle’s SchemaInstaller.

4. Dev Dependency Limitation: Installing dev-main may pull unstable code. Pin versions in composer.json:

   "require": {
       "common-gateway/sim-xml-bundle": "dev-main as 1.0.0"
   }
   

Debugging Tips

• Check Bundle Activation: Verify the bundle is loaded by inspecting Symfony’s kernel.debug or Laravel’s service container:

  $this->app->has(SimXmlBundle::class); // Should return true.
  

• XML Schema Validation Errors: Use Symfony’s Validator to debug schema issues:

  $validator = $this->container->get('validator');
  $errors = $validator->validate($xmlData);
  

• Log Symfony Events: Enable Symfony’s profiler or log events in Laravel:

  use Symfony\Component\EventDispatcher\EventDispatcherInterface;
  
  $dispatcher = $this->app->make(EventDispatcherInterface::class);
  $dispatcher->addListener('simxml.parse', function ($event) {
      \Log::debug('XML parsed:', $event->getData());
  });
  

Extension Points

1. Custom Parsers: Extend SimXmlParser to add Laravel-specific logic:

   class LaravelSimXmlParser extends SimXmlParser {
       public function parseWithLaravelLogic($xml) {
           // Add Eloquent model binding, etc.
       }
   }
   

2. API Integration: Use the bundle’s XML tools to validate API responses:

   $responseXml = file_get_contents('https://api.example.com/data.xml');
   $this->validateXml($responseXml, 'api_schema.xsd');
   

3. Testing: Mock the SimXmlParser in PHPUnit:

   $parser = $this->createMock(SimXmlParser::class);
   $parser->method('parse')->willReturn(['data' => 'test']);