README

A Laravel package for quickly generating design pattern boilerplate code. Stop writing repetitive pattern structures and focus on implementing your business logic!

✨ Features

5 Design Patterns Supported: Adapter, Strategy, Decorator, Factory, Observer
Artisan Commands: Simple, intuitive commands for each pattern
Smart Auto-Detection: Automatically detects Models, Services, Repositories
Customizable Namespaces: Use custom namespaces for generated files
Separate Files: Interface and implementation files generated separately
Laravel Integration: Full Laravel service provider integration

🚀 Installation

Install the package via Composer:

composer require heyosseus/laravel-pattern-maker

The package will automatically register its service provider thanks to Laravel's auto-discovery.

📋 Available Commands

Pattern	Command	Description
Adapter	`pattern:adapter`	Wrap external classes with unified interface
Strategy	`pattern:strategy`	Switch between algorithms at runtime
Decorator	`pattern:decorator`	Add responsibilities to objects dynamically
Factory	`pattern:factory`	Create objects without specifying exact class
Observer	`pattern:observer`	Notify multiple objects about state changes

🛠️ Usage Guide

1. Adapter Pattern

Purpose: Allows incompatible interfaces to work together. Perfect for integrating third-party libraries or services.

Basic Usage

php artisan pattern:adapter {AdapterName} {AdapteeClass}

Examples

Adapt a Service:

php artisan pattern:adapter PaymentAdapter StripeService

Result: Imports App\Services\StripeService

Adapt a Model:

php artisan pattern:adapter UserAdapter User

Result: Imports App\Models\User

Adapt External Library:

php artisan pattern:adapter GuzzleAdapter GuzzleHttp\\Client

Result: Imports GuzzleHttp\Client

Generated Files

app/Patterns/Adapter/PaymentAdapterInterface.php
app/Patterns/Adapter/PaymentAdapter.php

Custom Namespace

php artisan pattern:adapter PaymentAdapter StripeService --namespace=App\\Infrastructure\\Adapters

Usage Example

use App\Patterns\Adapter\PaymentAdapterInterface;

class OrderService
{
    public function __construct(private PaymentAdapterInterface $paymentAdapter) {}

    public function processPayment($amount)
    {
        return $this->paymentAdapter->handle($amount);
    }
}

2. Strategy Pattern

Purpose: Define a family of algorithms, encapsulate each one, and make them interchangeable at runtime.

Basic Usage

php artisan pattern:strategy {ContextName} {Strategy1?} {Strategy2?} ...

Examples

Payment Strategies:

php artisan pattern:strategy Payment CreditCardStrategy PayPalStrategy CryptoStrategy

Notification Strategies:

php artisan pattern:strategy Notification EmailStrategy SmsStrategy PushStrategy

Create Context Only:

php artisan pattern:strategy Shipping

Then add strategies later:

php artisan pattern:strategy Shipping StandardShipping ExpressShipping

Generated Files

app/Patterns/Strategy/PaymentStrategyInterface.php
app/Patterns/Strategy/PaymentContext.php
app/Patterns/Strategy/CreditCardStrategy.php
app/Patterns/Strategy/PayPalStrategy.php
app/Patterns/Strategy/CryptoStrategy.php

Usage Example

use App\Patterns\Strategy\PaymentContext;
use App\Patterns\Strategy\CreditCardStrategy;
use App\Patterns\Strategy\PayPalStrategy;

class PaymentService
{
    public function processPayment($type, $amount)
    {
        $strategy = match($type) {
            'credit_card' => new CreditCardStrategy(),
            'paypal' => new PayPalStrategy(),
            default => throw new \Exception('Invalid payment type')
        };

        $context = new PaymentContext($strategy);
        return $context->executeStrategy($amount);
    }
}

3. Decorator Pattern

Purpose: Attach additional responsibilities to objects dynamically without altering their structure.

Basic Usage

php artisan pattern:decorator {BaseName} {Decorator1?} {Decorator2?} ...

Examples

Notification Decorators:

php artisan pattern:decorator Notification LoggingDecorator CachingDecorator EncryptionDecorator

Data Processing Decorators:

php artisan pattern:decorator DataProcessor ValidationDecorator CompressionDecorator

Generated Files

app/Patterns/Decorator/NotificationComponentInterface.php
app/Patterns/Decorator/NotificationComponent.php
app/Patterns/Decorator/LoggingDecorator.php
app/Patterns/Decorator/CachingDecorator.php
app/Patterns/Decorator/EncryptionDecorator.php

Usage Example

use App\Patterns\Decorator\NotificationComponent;
use App\Patterns\Decorator\LoggingDecorator;
use App\Patterns\Decorator\CachingDecorator;

// Base notification
$notification = new NotificationComponent();

// Add logging
$notification = new LoggingDecorator($notification);

// Add caching
$notification = new CachingDecorator($notification);

// Execute with all decorators
$result = $notification->operation($data);

4. Factory Pattern

Purpose: Create objects without specifying the exact class to create. Useful for creating families of related objects.

Basic Usage

php artisan pattern:factory {FactoryName} {Product1?} {Product2?} ...

Examples

Vehicle Factory:

php artisan pattern:factory Vehicle Car Bike Truck

Database Connection Factory:

php artisan pattern:factory Database MySQL PostgreSQL SQLite

Report Factory:

php artisan pattern:factory Report PDFReport ExcelReport CSVReport

Generated Files

app/Patterns/Factory/VehicleFactoryInterface.php
app/Patterns/Factory/VehicleFactory.php
app/Patterns/Factory/Car.php
app/Patterns/Factory/Bike.php
app/Patterns/Factory/Truck.php

Usage Example

use App\Patterns\Factory\VehicleFactory;

class TransportService
{
    public function __construct(private VehicleFactory $vehicleFactory) {}

    public function createVehicle($type)
    {
        return $this->vehicleFactory->create($type);
    }
}

// Usage
$factory = new VehicleFactory();
$car = $factory->create('Car');
$bike = $factory->create('Bike');

5. Observer Pattern

Purpose: Define a one-to-many dependency between objects so that when one object changes state, all dependents are notified.

Basic Usage

php artisan pattern:observer {SubjectName} {Observer1?} {Observer2?} ...

Examples

Order Events:

php artisan pattern:observer Order EmailObserver LogObserver InventoryObserver

User Registration:

php artisan pattern:observer User WelcomeEmailObserver ProfileSetupObserver AnalyticsObserver

File Upload:

php artisan pattern:observer FileUpload VirusScanObserver ThumbnailObserver

Generated Files

app/Patterns/Observer/OrderObserverInterface.php
app/Patterns/Observer/OrderSubject.php
app/Patterns/Observer/EmailObserver.php
app/Patterns/Observer/LogObserver.php
app/Patterns/Observer/InventoryObserver.php

Usage Example

use App\Patterns\Observer\OrderSubject;
use App\Patterns\Observer\EmailObserver;
use App\Patterns\Observer\LogObserver;
use App\Patterns\Observer\InventoryObserver;

class OrderService
{
    private OrderSubject $subject;

    public function __construct()
    {
        $this->subject = new OrderSubject();

        // Attach observers
        $this->subject->attach(new EmailObserver());
        $this->subject->attach(new LogObserver());
        $this->subject->attach(new InventoryObserver());
    }

    public function createOrder($orderData)
    {
        // Create order logic here
        $order = Order::create($orderData);

        // Notify all observers
        $this->subject->notify(['order' => $order]);

        return $order;
    }
}

🎯 Real-World Use Cases

Payment Gateway Integration

# Create adapters for different payment providers
php artisan pattern:adapter StripeAdapter Stripe\\StripeClient
php artisan pattern:adapter PayPalAdapter PayPalCheckoutSdk\\Core\\PayPalHttpClient
php artisan pattern:adapter SquareAdapter SquareConnect\\Client

# Create strategy for payment processing
php artisan pattern:strategy Payment StripeStrategy PayPalStrategy SquareStrategy

Notification System

# Create observer for user events
php artisan pattern:observer User EmailObserver SmsObserver PushObserver SlackObserver

# Create decorator for notification enhancement
php artisan pattern:decorator Notification LoggingDecorator RetryDecorator RateLimitDecorator

File Storage System

# Create adapters for different storage providers
php artisan pattern:adapter S3Adapter Aws\\S3\\S3Client
php artisan pattern:adapter GoogleAdapter Google\\Cloud\\Storage\\StorageClient

# Create factory for file processors
php artisan pattern:factory FileProcessor ImageProcessor VideoProcessor DocumentProcessor

Logging System

# Create strategy for different log formats
php artisan pattern:strategy Logger JsonLogger XMLLogger PlainTextLogger

# Create decorator for log enhancement
php artisan pattern:decorator Logger TimestampDecorator ContextDecorator EncryptionDecorator

🔧 Advanced Features

Custom Namespaces

All commands support custom namespaces:

php artisan pattern:adapter PaymentAdapter StripeService --namespace=App\\Infrastructure\\Adapters
php artisan pattern:strategy Payment CreditCard --namespace=App\\Domain\\Strategies
php artisan pattern:decorator Notification Logging --namespace=App\\Services\\Decorators
php artisan pattern:factory Vehicle Car --namespace=App\\Factories
php artisan pattern:observer User Email --namespace=App\\Events\\Observers

Smart Class Detection

The package automatically detects and imports classes based on naming conventions:

Services: PaymentService → App\Services\PaymentService
Repositories: UserRepository → App\Repositories\UserRepository
Models: User → App\Models\User
Full Paths: Vendor\Package\Class → Uses as-is

Generated File Structure

app/
└── Patterns/
    ├── Adapter/
    │   ├── PaymentAdapterInterface.php
    │   └── PaymentAdapter.php
    ├── Strategy/
    │   ├── PaymentStrategyInterface.php
    │   ├── PaymentContext.php
    │   └── CreditCardStrategy.php
    ├── Decorator/
    │   ├── NotificationComponentInterface.php
    │   ├── NotificationComponent.php
    │   └── LoggingDecorator.php
    ├── Factory/
    │   ├── VehicleFactoryInterface.php
    │   ├── VehicleFactory.php
    │   └── Car.php
    └── Observer/
        ├── OrderObserverInterface.php
        ├── OrderSubject.php
        └── EmailObserver.php

🧪 Testing

After generating patterns, you should write tests for your implementations:

// tests/Unit/Patterns/Adapter/PaymentAdapterTest.php
class PaymentAdapterTest extends TestCase
{
    public function test_payment_adapter_processes_payment()
    {
        $mockService = Mockery::mock(StripeService::class);
        $adapter = new PaymentAdapter($mockService);

        $mockService->shouldReceive('handle')
            ->with(100)
            ->once()
            ->andReturn(['status' => 'success']);

        $result = $adapter->handle(100);

        $this->assertEquals(['status' => 'success'], $result);
    }
}

📚 Learning Resources

Design Patterns Explained

Adapter: Adapter Pattern
Strategy: Strategy Pattern
Decorator: Decorator Pattern
Factory: Factory Pattern
Observer: Observer Pattern

🤝 Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

Ideas for New Patterns

Builder Pattern
Command Pattern
Repository Pattern
Singleton Pattern
Proxy Pattern
Chain of Responsibility
Template Method

Development Setup

Clone the repository
Install dependencies: composer install
Run tests: composer test

📄 Requirements

PHP ^8.0|^8.1|^8.2|^8.3
Laravel ^9.0|^10.0|^11.0|^12.0

🏷️ Versioning

We use SemVer for versioning. For the versions available, see the tags on this repository.

📝 Changelog

v1.0.0 (2025-10-17)

Initial release
Added Adapter Pattern support
Added Strategy Pattern support
Added Decorator Pattern support
Added Factory Pattern support
Added Observer Pattern support
Smart class detection for Models, Services, Repositories
Separate interface and implementation files
Custom namespace support

👨‍💻 Credits

Author: Rati Rukhadze
Contributors: See contributors list

📄 License

The MIT License (MIT). Please see License File for more information.

🌟 Support

If you find this package helpful, please consider:

⭐ Starring the repository
🐛 Reporting bugs
💡 Suggesting new features
📖 Improving documentation

🚀 What's Next?

More design patterns
IDE integration and snippets
Pattern validation and suggestions
Performance optimizations
Enhanced documentation and examples

Happy coding with design patterns! 🎉

heyosseus / laravel-pattern-maker

Maintainers

Details

README

✨ Features

🚀 Installation

📋 Available Commands

🛠️ Usage Guide

1. Adapter Pattern

Basic Usage

Examples

Generated Files

Custom Namespace

Usage Example

2. Strategy Pattern

Basic Usage

Examples

Generated Files

Usage Example

3. Decorator Pattern

Basic Usage

Examples

Generated Files

Usage Example

4. Factory Pattern

Basic Usage

Examples

Generated Files

Usage Example

5. Observer Pattern

Basic Usage

Examples

Generated Files

Usage Example

🎯 Real-World Use Cases

Payment Gateway Integration

Notification System

File Storage System

Logging System

🔧 Advanced Features

Custom Namespaces

Smart Class Detection

Generated File Structure

🧪 Testing

📚 Learning Resources

Design Patterns Explained

🤝 Contributing

Ideas for New Patterns

Development Setup

📄 Requirements

🏷️ Versioning

📝 Changelog

v1.0.0 (2025-10-17)

👨‍💻 Credits

📄 License

🌟 Support

🚀 What's Next?