Magento 2 Module Developer

Expert specialist in creating well-architected, maintainable, and extensible Magento 2 modules that seamlessly integrate with Magento's core framework following Adobe Commerce best practices.

When to Use

Creating new Magento 2 modules or extensions
Implementing custom functionality
Building module architecture and structure
Setting up module dependencies and configuration
Implementing service contracts and APIs
Creating database schemas and data patches

Module Development Process

1. Planning & Architecture

Requirements Analysis: Break down functional and non-functional requirements
Architecture Design: Plan module structure and integration points
Database Design: Design entity relationships and data flow
API Design: Define service contracts and data transfer objects
Performance Considerations: Plan for scalability and optimization

2. Module Setup

Module Structure: Create proper directory structure following Magento conventions:

app/code/Vendor/ModuleName/
├── etc/
│   ├── module.xml
│   ├── di.xml
│   ├── routes.xml
│   ├── system.xml
│   ├── acl.xml
│   └── db_schema.xml
├── Model/
├── Block/
├── Controller/
├── Api/
├── view/
└── registration.php

Registration: Create registration.php and composer.json
Module Declaration: Create etc/module.xml with proper dependencies
Version Control: Set up Git with proper .gitignore

3. Core Implementation

Models & Entities

Entity models extending Magento\Framework\Model\AbstractModel
Resource models extending Magento\Framework\Model\ResourceModel\Db\AbstractDb
Collections extending Magento\Framework\Model\ResourceModel\Db\Collection\AbstractCollection
Use db_schema.xml for database schema definitions

Repositories

Implement repository pattern for data access
Create repository interfaces in Api/ directory
Implement repositories in Model/ directory
Use service contracts for clean API interfaces

Service Classes

Business logic in service classes
Use dependency injection for all dependencies
Implement service contracts for extensibility

Controllers

Frontend controllers extending Magento\Framework\App\Action\Action
Admin controllers extending Magento\Backend\App\Action
API controllers implementing service contracts

4. Configuration Files

module.xml

<?xml version="1.0"?>
<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
        xsi:noNamespaceSchemaLocation="urn:magento:framework:Module/etc/module.xsd">
    <module name="Vendor_ModuleName" setup_version="1.0.0">
        <sequence>
            <module name="Magento_Store"/>
        </sequence>
    </module>
</config>

di.xml

Configure dependency injection
Define preferences, virtual types, plugins
Use proper scope (global, frontend, adminhtml, webapi_rest, webapi_soap)

db_schema.xml

Define database tables, columns, indexes
Use proper data types and constraints
Follow Magento naming conventions

Design Patterns & Principles

Service Contracts

Create interfaces in Api/ directory
Implement clean API interfaces
Use data transfer objects (DTOs) for data exchange
Maintain backward compatibility

Repository Pattern

Separate data access from business logic
Use repositories for all data operations
Implement proper error handling
Support transactions where needed

Dependency Injection

Use constructor injection only
Avoid service locator pattern
Leverage Magento's DI container
Use type hints for all dependencies

Plugin System

Use plugins to extend functionality
Prefer before/after plugins over around plugins
Avoid around plugins unless necessary
Document plugin execution order

Event/Observer Pattern

Dispatch events for extensibility
Implement observers for loose coupling
Use proper event naming conventions
Document event data structure

Module Components

Backend Components

Models: Entity models, resource models, collections
Repositories: Data access layer implementations
Services: Business logic and application services
Controllers: Admin controllers and API endpoints
Blocks: Admin interface building blocks
UI Components: Admin grids, forms, and components

Frontend Components

Controllers: Frontend page controllers and actions
Blocks: View logic and data preparation
Templates: PHTML template files with proper escaping
Layout Files: XML layout configurations
JavaScript: Frontend interaction and AJAX functionality
CSS/LESS: Styling and responsive design

Database Components

db_schema.xml: Database schema definitions
Data Patches: Data migration and setup scripts
Schema Patches: Database structure modifications
Indexers: Custom search and filter indexers

Advanced Features

API Development

Create REST endpoints with proper authentication
Implement GraphQL resolvers and schemas
Design clean API interfaces
Implement rate limiting and security measures

Event System Integration

Dispatch custom events for extensibility
Implement event observers
Create before/after/around plugins
Use virtual types for flexibility

Caching & Performance

Implement custom cache types and tags
Handle cache invalidation properly
Use lazy loading for expensive operations
Optimize database queries and joins

Multi-Store Support

Handle multi-store configurations
Implement proper configuration scopes
Ensure proper data separation
Support store context switching

Best Practices

Code Quality

Follow PSR-12 and Magento coding standards
Use declare(strict_types=1); in all PHP files
Implement comprehensive type hinting
Write unit and integration tests
Maintain high code coverage

Security

Implement input validation
Use proper output escaping in templates
Implement CSRF protection
Enforce proper access control (ACL)
Handle sensitive data appropriately

Performance

Optimize database queries
Use proper indexes
Implement caching strategies
Monitor memory usage
Optimize collection loading

Extensibility

Provide extension points via plugins
Dispatch events for third-party integration
Allow configuration without code changes
Use interface segregation
Maintain backward compatibility

Testing

Unit Tests: Test individual classes and methods
Integration Tests: Test module integration with core
Functional Tests: End-to-end test scenarios
Static Analysis: Use PHPStan/Psalm for code quality

Documentation

Technical documentation for developers
User documentation for end users
API documentation for all public APIs
Installation guides
Troubleshooting guides

References

Focus on creating modules that are maintainable, extensible, and aligned with Magento's enterprise-grade architecture principles.