Framework Laravel Package

Technical Evaluation

Architecture Fit

• PHP 8.4 Compatibility: The new release (v1.10.0) introduces nullable type fixes, ensuring compatibility with PHP 8.4. This is critical for projects adopting newer PHP versions, as it:
  • Reduces technical debt by aligning with modern PHP standards.
  • Future-proofs the integration, avoiding migration pain when upgrading PHP.
  • Mitigates runtime errors from strict typing in Laravel 11+ (which may require PHP 8.4).
• Hybrid Architecture Clarity:
  • The package’s focus on type safety (e.g., nullable types) suggests improved stability for Laravel-WordPress data interactions, such as:
    • Eloquent model mappings to WordPress tables (e.g., Post::whereNull('status')).
    • Service container bindings for WordPress globals (e.g., WP_User|null).
  • Trade-offs remain:
    • Performance: PHP 8.4’s JIT may introduce overhead if WordPress’s legacy code isn’t optimized.
    • Debugging: Strict types could expose hidden null issues in WordPress hooks/filters (e.g., $_POST data).

Integration Feasibility

• Core Laravel Compatibility:
  • Pros:
    • PHP 8.4 support aligns with Laravel 11’s requirements, enabling seamless use of:
      • Attributes (e.g., #[\Route(...)] in Laravel 11).
      • Readonly properties for WordPress data models.
    • Reduced risk of TypeError in Laravel’s dependency injection when binding WordPress services.
  • Cons:
    • Backward Compatibility: Projects on PHP 8.2/8.3 may need to upgrade, requiring:
      • Docker/PHP version updates.
      • Testing for deprecated functions (e.g., create_function in WordPress plugins).
• WordPress Integration:
  • Pros:
    • Nullable types improve safety for optional WordPress data (e.g., get_post_meta() returning null).
    • Easier adoption of Laravel’s strict mode for hybrid projects.
  • Cons:
    • Plugin/Theme Risks: Third-party WordPress code (e.g., old plugins) may throw TypeError if not updated. Mitigate by:
      • Wrapping WordPress calls in @phpstan-ignore-line or runtime checks.
      • Using wpstarter:validate Artisan command (if added in future releases).

Technical Risk

Key Questions

1. PHP Version Strategy:
   • Is the team ready to upgrade to PHP 8.4? If not, can the project delay this release or use a polyfill (e.g., ramsey/collection for nullable types)?
   • Will shared hosting support PHP 8.4? If not, consider a VPS with PHP-FPM or Laravel Forge.
2. Strict Typing Adoption:
   • Should the project enable declare(strict_types=1) globally in Laravel, or only in hybrid layers (e.g., app/WpStarter)?
   • How will WordPress’s dynamic function calls (e.g., call_user_func_array) interact with PHP 8.4’s stricter type system?
3. Plugin/Theme Vendor Lock-in:
   • Are there critical WordPress plugins that cannot be updated to PHP 8.4? If so, can they be isolated (e.g., via mu-plugins)?
4. Performance Impact:
   • Has the team benchmarked PHP 8.4’s JIT with WordPress? Expect ~10-20% slower startup if WordPress’s wp-settings.php is unoptimized.
5. Testing Updates:
   • Are PHPUnit tests updated to use null assertions (e.g., assertNull() instead of assertFalse())?
   • Should browser tests (e.g., Cypress) validate PHP 8.4’s error reporting (e.g., E_DEPRECATED for old WordPress functions)?

Integration Approach

Stack Fit

• PHP 8.4-Specific Adjustments:
  • Laravel:
    • Enable Laravel’s strict mode (APP_STRICT_MODE=true in .env) to catch type issues early.
    • Use Laravel 11’s attributes for WordPress hook bindings:

      #[Hook('init')]
      public function onWordPressInit(): void { ... }
      

  • WordPress:
    • Replace loose global $wpdb; with typed bindings:

      $wpdb = app(\WPStarter\Database\WPDB::class);
      

    • Use wpstarter:generate-types (if added) to scaffold nullable type hints for WordPress models.
• Database:
  • Leverage PHP 8.4’s union types for hybrid queries:

    public function findPost(int|string $id): ?Post { ... }
    

  • Migrate legacy wp_* tables to use Laravel’s strict schema validation.

Migration Path

1. Phase 0: PHP 8.4 Readiness (New)

   • Goal: Prepare the stack for PHP 8.4 before integrating wpstarter/framework.
   • Actions:
     • Update Dockerfile/php.ini to PHP 8.4:

       FROM laravel/php84:latest
       

     • Run composer require --dev phpstan/phpstan and audit:

       phpstan analyse --level 8 app/WpStarter
       

     • Patch WordPress core/plugins with nullable type casts:

       $meta = get_post_meta($post_id, 'key', true) ?? null;
       

2. Phase 1: Decoupled Coexistence (Updated)

   • New: Add PHP 8.4-specific configurations:
     • Configure wpstarter.php:

       'php_version' => '8.4',
       'strict_types' => true,
       

     • Use Laravel’s APP_DEBUG=false in production to hide WordPress’s E_DEPRECATED warnings.

3. Phase 2: Feature Integration (Updated)

   • New: Exploit PHP 8.4 features for hybrid logic:
     • Attributes for Hooks:

       #[Hook('wp_loaded', priority: 100)]
       public function cacheWordPressData(): void { ... }
       

     • Union Types for API Responses:

       public function getUserData(int $id): array|false { ... }
       

Compatibility

• PHP 8.4-Specific:
  • Breaking Changes: None in this release, but future PHP 8.4 features (e.g., readonly properties) may require updates to WordPress’s WP_* classes.
  • Dependencies:
    • Update composer.json:

      "require": {
          "php": "^8.4",
          "wpstarter/framework": "^1.10.0"
      }
      

    • Resolve conflicts with wp-cli/wp-cli (if used) via:

      composer why-not wp-cli/wp-cli
      

• WordPress Versions:
  • Test with WordPress 6.5+ for PHP 8.4 compatibility (e.g., wp-includes/load.php).
  • Use wpstarter:check-compatibility (if added) to validate.

Sequencing

1. Prerequisites (Updated):
   • Step 0: Upgrade PHP environment:

     # Example for Laravel Sail
     sail build --no-cache --php-version=8.4
     

   • Step 1: Install wpstarter/framework with PHP 8.4 flags:

     composer require wpstarter/framework --with-all-dependencies
     

   • Step 2: Configure php.ini:

     zend.assertions = -1  # Disable assertions for WordPress compatibility