Pdo Snapshot Store Laravel Package

Technical Evaluation

Architecture Fit

• Event Sourcing/Event Store Compatibility: Remains unchanged. The package is still optimized for Prooph Event Store in CQRS/ES architectures, providing snapshot storage to reduce event replay overhead. Non-ES use cases remain limited.
• PHP 8 Compatibility: New in v1.6.0 – Explicit support for PHP 8.x (e.g., named arguments, union types) aligns with Laravel 9+/10+ and modern Prooph packages. This reduces potential runtime deprecation warnings and enables features like construct property promotion.
• Database Agnosticism: Unchanged. Still relies on PDO, requiring manual schema setup (no migrations included).
• Immutability & Consistency: No changes. Snapshots remain write-once and version-tied to aggregates.

Integration Feasibility

• Prooph Ecosystem Dependency: Unchanged. Still requires prooph/event-store or compatible event-sourced architecture.
• Schema Requirements: Unchanged. Manual table setup (e.g., snapshots, snapshot_metadata) is mandatory.
• Serialization: Unchanged. Defaults to serialize(), but PHP 8’s strict typing may now surface issues with non-serializable properties (e.g., DateTimeImmutable vs. DateTime) more aggressively.
• Laravel Compatibility:
  • PHP 8 Alignment: Laravel 9/10’s PHP 8+ support now fully compatible with this package, reducing version skew risks.
  • Dependency Injection: No changes, but PHP 8’s constructor property promotion may simplify service binding (e.g., shorter new \Prooph\PDO\Snapshot\SnapshotStore($pdo, 'snapshots')).

Technical Risk

• Vendor Lock-in: Unchanged. Tight coupling with Prooph persists.
• Performance Overhead: Unchanged. Snapshots still add write complexity and storage duplication.
• Debugging Complexity: Unchanged. Serialized snapshots remain opaque in logs.
• Laravel-Specific Risks:
  • PHP 8 Strictness: New in v1.6.0. Potential type errors if aggregates contain non-serializable PHP 8 features (e.g., array{} short syntax in closures).
  • Transaction Conflicts: Unchanged. Laravel’s transactions may still clash with Prooph’s event store transactions.
• Deprecation Risk:
  • Prooph Maintenance: Package is abandoned (last release 2022). PHP 8 support is a last-resort effort to avoid breaking users. Future Laravel/PHP upgrades may require forking or migrating to alternatives (e.g., axiom/axiom).

Key Questions

1. PHP 8 Migration Readiness
   • Are your aggregates fully PHP 8 compatible (e.g., no __set_state() hacks, no deprecated serialize() behavior)?
   • Will you test snapshot serialization with PHP 8’s strict types enabled?
2. Prooph Ecosystem Longevity
   • Have you assessed alternatives (e.g., spiral/event-store, axiom/axiom) for long-term maintenance?
   • What’s your fallback plan if Prooph packages stop receiving updates?
3. Snapshot Serialization
   • Are you using custom serializers (e.g., JSON, MessagePack) to avoid serialize() limitations in PHP 8?
   • How will you handle new PHP 8 types (e.g., array{} in snapshots)?
4. CI/CD Impact
   • Has your GitHub Actions setup (replacing Travis) been updated to test PHP 8 snapshots?
   • Are you using Laravel Pint/Pint to enforce PHP 8 syntax in aggregates?
5. Downgrade Risk
   • Can you downgrade PHP if this package introduces runtime issues (e.g., serialize() failures)?

Integration Approach

Stack Fit

• Laravel Compatibility:
  • PHP 8 Support: Now fully aligned with Laravel 9/10. Update phpunit/phpunit and laravel/framework to PHP 8+ versions.
  • Service Binding: Leverage PHP 8’s constructor property promotion for cleaner bindings:

    $this->app->bind(\Prooph\Snapshot\SnapshotStoreInterface::class, function ($app) {
        return new \Prooph\PDO\Snapshot\SnapshotStore(
            pdo: $app['db']->connection('mysql')->getPdo(),
            tableName: 'snapshots'
        );
    });
    

• Prooph Integration: Unchanged. Still requires prooph/event-store v4+ (PHP 8 compatible).
• Alternatives Considered:
  • Axiom: Modern event store with native Laravel support and active maintenance.
  • Spiral Framework: Offers event sourcing with better PHP 8 integration.

Migration Path

1. Phase 0: PHP 8 Upgrade Prep
   • Update phpunit/phpunit to ^9.5 and laravel/framework to ^9.0|^10.0.
   • Run php artisan vendor:publish --tag=pint and update .php-cs-fixer.dist.php for PHP 8 syntax.
2. Phase 1: Schema Validation
   • Verify snapshot tables are PHP 8 compatible (e.g., no enum types that serialize poorly).
3. Phase 2: Prooph Configuration
   • Update Prooph packages to PHP 8-compatible versions:

     composer require prooph/event-store:^4.0 prooph/pdo-snapshot-store:^1.6
     

   • Rebind snapshot store with PHP 8 syntax (see above).
4. Phase 3: Aggregate Testing
   • Test snapshot serialization with PHP 8 aggregates:

     $snapshot = serialize($aggregate->getSnapshot());
     $unserialized = unserialize($snapshot);
     assert($unserialized instanceof stdClass); // Or custom DTO
     

   • Use PHPUnit’s expectDeprecation() to catch serialize() warnings.
5. Phase 4: CI/CD Update
   • Replace Travis with GitHub Actions (already done in this release). Add PHP 8 test matrix:

     jobs:
       test:
         runs-on: ubuntu-latest
         strategy:
           matrix:
             php: ['8.0', '8.1', '8.2']
     

Compatibility

• Laravel Versions: Now fully compatible with Laravel 9/10 (PHP 8+).
• Prooph Version: Requires prooph/event-store:^4.0 (PHP 8 compatible).
• PDO Drivers: Unchanged. Still any PDO-compatible database.
• Conflict Areas:
  • PHP 8 Strictness: serialize() may fail on:
    • Resources (e.g., file handles).
    • Closures with use of non-serializable objects.
    • New PHP 8 types (e.g., array{} in closures).
  • Transactions: Unchanged. Still risk of conflicts with Laravel’s DB::transaction().

Sequencing

1. Pilot Aggregate: Start with a PHP 8-compatible aggregate (e.g., Invoice with simple properties).
2. Snapshot Benchmark: Compare event replay times with/without snapshots in PHP 8.
3. Gradual Rollout: Enable snapshots for read-heavy aggregates first (e.g., ProductCatalog).
4. Monitoring: Track:
   • PHP 8 deprecation warnings during snapshot operations.
   • Unserialization failures (indicating corrupt snapshots).
   • Performance regression from PHP 8’s stricter type checks.

Operational Impact

Maintenance

• Schema Changes: Unchanged. Still requires manual migrations.
• Dependency Updates:
  • Prooph Risk: Package is abandoned. PHP 8 support is a temporary fix. Plan for:
    • Forking the repository if critical bugs arise.
    • Migrating to axiom/axiom or spiral/event-store in 12–24 months.
  • Laravel Upgrades: PHP 8+ snapshots may break with future Laravel versions (e.g., if serialize() behavior changes).
• Logging:
  • Add PHP 8-specific logs (e.g., Snapshot serialization failed for [aggregate_id]: [error]).
  • Monitor for unexpected serialize() warnings in production.

Support

• Debugging Snapshots:
  • Use PHP 8’s error reporting to catch serialization issues early:

    error_reporting(E_ALL);
    ini_set('display_errors', '1');
    $snapshot = serialize($aggregate->getSnapshot()); // Will throw on failure
    

  • Deserialize in Tinker:

    php artisan