Default Laravel Package

Getting Started

Minimal Steps

1. Install the Package:

   composer require php-standard-library/default
   

2. Implement the Interface: Add DefaultInterface to a class and define getDefault():

   use PHPStandardLibrary\Default\DefaultInterface;
   
   class User implements DefaultInterface
   {
       public function getDefault(): static
       {
           return new static([
               'name' => 'Guest',
               'email' => null,
           ]);
       }
   }
   

3. First Use Case: Replace hardcoded defaults in Laravel’s service layer:

   // Before
   $user = new User(['name' => 'Guest']);
   
   // After
   $user = User::getDefault();
   

Where to Look First

• Package Docs: PHP Standard Library - Default (if available).
• Interface Source: DefaultInterface.php for the contract.
• Laravel Integration: Focus on AppServiceProvider bindings and testing patterns.

Implementation Patterns

Usage Patterns

1. Service Layer Defaults: Bind defaults in AppServiceProvider:

   $this->app->bind('default-user', fn() => User::getDefault());
   

   Use in controllers:

   $user = app('default-user');
   

2. Repository Pattern: Enforce DefaultInterface in RepositoryInterface:

   interface RepositoryInterface {
       public function getDefault(): static;
   }
   

3. API Responses: Standardize default Resource objects:

   class UserResource implements DefaultInterface {
       public function getDefault(): static {
           return new static(['data' => null]);
       }
   }
   

4. Testing: Replace mocks with getDefault():

   // Before
   $mockUser = Mockery::mock(User::class);
   
   // After
   $defaultUser = User::getDefault();
   

Workflows

1. New Class Adoption:

   • Add DefaultInterface to the class.
   • Implement getDefault() with sensible defaults.
   • Bind to Laravel’s container if needed.

2. Refactoring:

   • Use php artisan tinker to test getDefault():

     php artisan tinker
     >>> User::getDefault()
     

   • Replace new Class() with Class::getDefault() in legacy code.

3. Modular Applications:

   • Use traits for shared defaults:

     trait HasDefaultConfig {
         public function getDefault(): static {
             return new static(config('app.defaults'));
         }
     }
     

Integration Tips

• Laravel Facades: Extend facades to use defaults:

  class UserFacade extends \Illuminate\Support\Facades\Facade {
      public static function default() {
          return app('default-user');
      }
  }
  

• Dynamic Defaults: Combine with Laravel’s config():

  public function getDefault(): static {
      return new static(config('app.default_user_attributes'));
  }
  

• Performance: Lazy-load defaults via container:

  $this->app->when(User::class)
      ->needs('$default')
      ->give(fn() => User::getDefault());
  

Gotchas and Tips

Pitfalls

1. Eager Initialization:

   • Issue: Calling getDefault() in boot() may load defaults too early.
   • Fix: Use Laravel’s container bindings for lazy loading.

2. State Contamination:

   • Issue: Defaults shared across requests (e.g., static properties).
   • Fix: Ensure defaults are immutable or request-scoped:

     public function getDefault(): static {
         return new static(); // No shared state
     }
     

3. Interface Bloat:

   • Issue: Adding DefaultInterface to every class feels redundant.
   • Fix: Use traits or limit adoption to critical classes.

4. Testing Overhead:

   • Issue: Tests may need updates to use getDefault().
   • Fix: Gradually migrate tests; use method_exists() checks for backward compatibility.

Debugging

• Undefined Method Errors:

  • Cause: Forgetting to implement getDefault().
  • Debug: Run php artisan ide-helper:generate to check interfaces.

• Default State Issues:

  • Cause: getDefault() returns invalid data.
  • Debug: Add validation in getDefault():

    public function getDefault(): static {
        $default = new static();
        if (!$default->isValid()) {
            throw new \RuntimeException('Invalid default state');
        }
        return $default;
    }
    

Config Quirks

• Laravel Bindings:
  • Override defaults via container:

    $this->app->bind('default-user', fn() => new User(['name' => 'Admin']));
    

• Environment-Specific Defaults: Use Laravel’s config():

  public function getDefault(): static {
      return new static(config('app.defaults.' . env('APP_ENV')));
  }
  

Extension Points

1. Custom Default Factories: Create a DefaultFactory class to centralize default logic:

   class DefaultFactory {
       public static function user(): User {
           return User::getDefault();
       }
   }
   

2. Dynamic Defaults via Plugins: Allow plugins to override defaults:

   $this->app->singleton('default-user-plugin', fn() => new PluginDefaultUser());
   

3. Laravel Service Provider Extensions: Add default bindings in a dedicated provider:

   class DefaultServiceProvider extends ServiceProvider {
       public function register() {
           $this->app->bind('default-user', fn() => User::getDefault());
       }
   }
   

Laravel-Specific Tips

• Use app() for Flexibility: Prefer app('default-user') over User::getDefault() for easier mocking in tests.
• Combine with Collections: Standardize empty collections:

  class EmptyCollection implements DefaultInterface {
      public function getDefault(): static {
          return new static();
      }
  }
  

• API Resources: Enforce defaults in JsonResource:

  class UserResource extends JsonResource implements DefaultInterface {
      public function getDefault(): static {
          return new static(new User());
      }
  }