php-patterns
/php-patterns
Apply PHP design patterns — Repository, Factory, Strategy, Decorator, Observer, Singleton, Builder, and Dependency Injection patterns in PHP. Use when architecting PHP applications or understanding patterns used in Magento and other frameworks.
- Author
- OrcaQubits ↗
- Repository
- agentic-commerce-skills-plugins ↗
- Licence
- MIT
- Last repository change
- 14.09.2026
Assessment and security
- Files in this package
- 1
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 0
No signals detected. Repository changed on 14.09.2026, without references to retired models or APIs.
MIT, open: use and modify while retaining author attribution.
What it does and when to use it
Apply PHP design patterns — Repository, Factory, Strategy, Decorator, Observer, Singleton, Builder, and Dependency Injection patterns in PHP. Use when architecting PHP applications or understanding patterns used in Magento and other frameworks.
Original author description
Apply PHP design patterns — Repository, Factory, Strategy, Decorator, Observer, Singleton, Builder, and Dependency Injection patterns in PHP. Use when architecting PHP applications or understanding patterns used in Magento and other frameworks.
How it works
- Before writing code
- Creational Patterns
- Structural Patterns
- Behavioral Patterns
- Architectural Patterns
- Anti-Patterns to Avoid
- Best Practices
SKILL.md preview
--- name: php-patterns description: Apply PHP design patterns — Repository, Factory, Strategy, Decorator, Observer, Singleton, Builder, and Dependency Injection patterns in PHP. Use when architecting PHP applications or understanding patterns used in Magento and other frameworks. allowed-tools: Read, Write, Edit, Bash, Grep, Glob, WebSearch, WebFetch --- # PHP Design Patterns ## Before writing code **Fetch live docs**: Web-search `php design patterns examples` for current community patterns and best practices. For Magento-specific patterns, web-search `site:developer.adobe.com commerce php development components`. ## Creational Patterns ### Factory Creates objects without exposing instantiation logic. In Magento, auto-generated Factory classes (`SomeModelFactory`) create non-injectable objects via `$factory->create()`. **When to use**: When you need new instances (entities, models) rather than shared singletons. When the caller shouldn't know the concrete class. ### Builder Constructs complex objects step by step. Magento's `SearchCriteriaBuilder`, `FilterBuilder`, `SortOrderBuilder` follow this pattern. **When to use**: When object construction requires many optional parameters or multi-step assembly. ### Singleton (Shared Instance) Single instance shared across the application. Magento's Object Manager shares instances by default. Explicit singleton is generally an anti-pattern — prefer DI container sharing. **When to use**: Rarely — let the DI container manage instance sharing. ## Structural Patterns ### Proxy Delays instantiation of resource-intensive dependencies. Magento auto-generates Proxy classes (`SomeClass\Proxy`) that create the real object only when a method is called. **When to use**: When a class injects a heavy dependency it doesn't always use. ### Decorator Wraps an object to add behavior without modifying the original. Used in Magento composite components and cache decorators. **When to use**: When you need to add behavior to an object dynamically without subclassing. ### Composite Treats individual objects and compositions uniformly. Magento's UI component tree and layout container system follow this pattern. **When to use**: When you have tree-structured data or components. ## Behavioral Patterns ### Strategy Defines a family of algorithms, encapsulates each one, makes them interchangeable. Magento shipping carriers and payment methods are strategy implementations. **When to use**: When you have multiple algorithms for the same task and want runtime selection. ### Observer Defines a one-to-many dependency. When one object changes state, all dependents are notified. Magento's event/observer system is a direct implementation. **When to use**: When changes in one object should trigger actions in others without tight coupling. ### Repository Mediates between domain and data mapping layers. Magento's repository interfaces (`ProductRepositoryInterface`) centralize all data access through a clean API. **When to use**: Always — for any data access beyond simple reads. It's the standard Magento pattern. ### Command Encapsulates a request as an object. Magento's Payment Gateway Command pattern uses this — authorize, capture, refund are separate command objects. **When to use**: When you need to parameterize, queue, or log requests. ## Architectural Patterns ### Dependency Injection Objects receive their dependencies through constructors rather than creating them. Magento's DI container (Object Manager + di.xml) is the foundation of the entire framework. **When to use**: Always — it's the core pattern. Inject interfaces, not concrete classes. ### Service Layer Defines an application's boundary with a layer of services that encapsulates business logic. Magento's Service Contracts (interfaces in `Api/`) form this layer. **When to use**: Always — expose module functionality through service interfaces. ### Data Transfer Object (DTO) Simple objects that carry data between processes. Magento's Data Interfaces (`Api/Data/`) are DTOs — they have getters/setters but no business logic. **When to use**: When passing data across architectural boundaries (API, service layer). ## Anti-Patterns to Avoid - **God Object** — classes that do too much (split into focused services) - **Service Locator** — calling Object Manager directly (use constructor injection) - **Anemic Domain Model** — models with only getters/setters (add behavior where appropriate) - **Tight Coupling** — depending on concrete classes (depend on interfaces) - **Hard-coded Dependencies** — instantiating with `new` (use factories or DI) ## Best Practices - Program to interfaces, not implementations - Favor composition over inheritance - Keep classes focused (Single Responsibility) - Use DI container for dependency management - Use factories for creating non-shared instances - Use proxies for lazy-loading expensive dependencies - Use the strategy pattern for swappable algorithms - Document which pattern a class implements Fetch current framework documentation for exact interface signatures and implementation patterns before applying.
Versions
| Repository | Score | Licence |
|---|---|---|
| This page · OrcaQubits/agentic-commerce-skills-plugins | 100 | MIT |
| OrcaQubits/agentic-commerce-skills-plugins | 100 | MIT |
Database snapshot: 13.11.2026 · package version 7b1e46603356 (SHA-256 digest of the entire package)
Downloads in the last 30 days: 0 · ranking
Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.
Similar skills
- 100design-patterns-implementation
Apply appropriate design patterns (Singleton, Factory, Observer, Strategy, etc.) to solve architectural problems. Use when refactoring code architecture, implementing extensible systems, or following SOLID principles. - 90design-patterns
Select a design pattern from a symptom — strategy, observer, factory, adapter, decorator. Use when a structure resists change, or choosing between Gang-of-Four patterns. - 95design-patterns
Common design patterns with Java examples (Factory, Builder, Strategy, Observer, Decorator, etc.). Use when user asks "implement pattern", "use factory", "strategy pattern", or when designing extensible components. - 100design-patterns
Use this skill whenever the user wants to identify, apply, or refactor toward design patterns in their codebase. Triggers include: "apply design patterns", "identify patterns", "what patterns should I use", "refactor to strategy pattern", "apply factory method", "use observer… - 100design-patterns
Identifies, implements, and refactors code using standard Design Patterns (GoF + Modern). Use when: design pattern, refactor pattern, strategy pattern, observer pattern, factory pattern, singleton. - 100design-patterns-ruby
Comprehensive Ruby implementations of Gang of Four (GoF) design patterns. Use when implementing object-oriented design solutions, refactoring to reduce coupling, solving architecture problems, or when user mentions specific patterns (Factory, Singleton, Observer, Strategy, etc.) in Ruby context.