Sock Api Bundle Laravel Package

Technical Evaluation

Architecture Fit

• Symfony/Laravel Compatibility: The package is a Symfony bundle, not a Laravel package, which introduces a fundamental architectural mismatch. Laravel and Symfony have divergent service container, dependency injection, and routing systems, requiring significant abstraction or middleware layers to bridge the gap.
• Use Case Alignment: The bundle provides a SOAP API client wrapper (for SockAPI), which may fit if your Laravel app needs to consume a SOAP-based government API (e.g., Belgian public sector APIs like SockAPI). However, Laravel’s native SoapClient or libraries like php-soap may suffice without a Symfony bundle.
• Modern PHP/Laravel Standards: The package was last updated in 2018, predating Laravel’s adoption of PSR-15 middleware, Laravel HTTP clients, and dependency injection best practices. Integration risks include:
  • Service container conflicts (Symfony’s ContainerInterface vs. Laravel’s Container).
  • Routing conflicts (Symfony’s Routing component vs. Laravel’s router).
  • Configuration management (Symfony’s YAML/XML vs. Laravel’s PHP/ENV).

Integration Feasibility

• Direct Integration: Not recommended due to Symfony’s tight coupling with its framework. Workarounds include:
  • Wrapper Class: Create a Laravel service class that instantiates the bundle’s core logic (e.g., SockAPIClient) while abstracting Symfony dependencies.
  • Standalone Library: Extract the bundle’s SockAPI logic into a PSR-compliant PHP library (e.g., using composer require of the underlying digipolisgent/sock-api package if available).
• Alternative Libraries: Evaluate Laravel-native SOAP clients like:
  • php-soap (built-in).
  • glow/soap (modern, PSR-18 compliant).
  • daniel-staerk/soap-client (Laravel-friendly).

Technical Risk

Key Questions

1. Why Symfony? Is the bundle’s SOAP-specific logic (e.g., Belgian SockAPI quirks) not available in Laravel-native libraries?
2. Future-Proofing: Will the team maintain a wrapper, or is this a short-term fix for a legacy API?
3. Performance: Does the bundle add overhead (e.g., Symfony’s event system) that Laravel’s lightweight HTTP client avoids?
4. Alternatives: Has the team evaluated SOAP-to-REST proxies (e.g., converting the SOAP API to JSON via a microservice)?
5. Compliance: Does the Belgian SockAPI require specific Symfony bundle features (e.g., authentication middleware)?

Integration Approach

Stack Fit

• Laravel Compatibility: Low due to Symfony’s framework-specific components. The bundle assumes:
  • Symfony’s HttpKernel for request handling.
  • Symfony’s DependencyInjection for configuration.
  • Symfony’s Routing for URL generation.
• Recommended Stack:
  • Core: Laravel 10+ with PHP 8.1+.
  • SOAP Layer: Use Laravel’s SoapClient or a PSR-18-compliant client (e.g., php-http/soap-client).
  • Abstraction: Create a Laravel service that mimics the bundle’s interface but avoids Symfony dependencies.

Migration Path

1. Assessment Phase:
   • Audit the bundle’s SockAPI usage (e.g., authentication, request/response transformations).
   • Identify minimal viable functionality (e.g., "Can we replace 80% of the bundle’s logic with SoapClient?").
2. Extraction Phase:
   • Fork the bundle and strip Symfony dependencies, leaving only the SockAPI client logic.
   • Publish as a Composer package (e.g., vendor/sock-api-client) with Laravel-friendly interfaces.
3. Integration Phase:
   • Register the extracted client as a Laravel service provider:

     $this->app->singleton(SockAPIClient::class, function ($app) {
         return new SockAPIClient($app['config']['sock_api.wsdl']);
     });
     

   • Replace Symfony’s Container calls with Laravel’s bind() or make().
4. Testing Phase:
   • Validate SOAP requests/responses match the original bundle’s behavior.
   • Test edge cases (e.g., authentication failures, malformed XML).

Compatibility

• Symfony Components: The bundle uses:
  • symfony/http-kernel (for HTTP handling).
  • symfony/dependency-injection (for configuration).
  • Workaround: Use Laravel’s Illuminate\Http and Illuminate/Container as drop-in replacements where possible.
• PHP Version: The bundle targets PHP 5.6–7.1. Laravel 10+ requires PHP 8.1+, so:
  • Update the extracted logic to PHP 8.1+.
  • Use strict typing and named arguments for modern Laravel compatibility.
• Configuration: Replace Symfony’s YAML/XML config with Laravel’s config/sock_api.php:

  'wsdl' => env('SOCK_API_WSDL_URL'),
  'auth' => [
      'username' => env('SOCK_API_USER'),
      'password' => env('SOCK_API_PASS'),
  ],
  

Sequencing

1. Phase 1 (0–2 weeks): Evaluate alternatives (SOAP libraries, REST proxies).
2. Phase 2 (2–4 weeks): Extract and refactor the bundle into a Laravel-compatible package.
3. Phase 3 (1–2 weeks): Integrate the package into the Laravel app with tests.
4. Phase 4 (Ongoing): Deprecate the Symfony bundle in favor of the new package.

Operational Impact

Maintenance

• Short-Term:
  • High effort to extract/refactor the bundle.
  • Dependency management: Pin Symfony components to avoid breaking changes.
• Long-Term:
  • Lower maintenance if using a standalone SOAP client (e.g., php-soap).
  • Risk: If the original bundle is updated (unlikely), integration may break.
• Documentation:
  • Document the abstraction layer (e.g., "This service replaces Symfony’s SockAPI with Laravel’s SoapClient").
  • Note deviations from the original bundle’s behavior.

Support

• Vendor Lock-in: The bundle has no maintainers (last release: 2018). Support relies on:
  • Community forks (none visible).
  • Laravel SOAP libraries (e.g., php-soap has active PHP core support).
• Debugging:
  • Symfony-specific errors (e.g., Container not found) will require custom error handling.
  • SOAP-specific issues (e.g., WSDL parsing) may need manual XML validation.
• Fallback Plan:
  • If integration fails, revert to SoapClient or implement a REST proxy.

Scaling

• Performance:
  • The bundle’s Symfony overhead may increase memory/CPU usage compared to a lightweight SoapClient.
  • Mitigation: Benchmark both approaches (bundle wrapper vs. native SoapClient).
• Concurrency:
  • SOAP calls are blocking. Use Laravel’s queues (bus:queue) for long-running requests.
  • Avoid synchronous SOAP calls in high-traffic routes.
• Horizontal Scaling:
  • No impact if using stateless SOAP requests. Cache WSDL responses if possible.

Failure Modes