1---
2name: php-pro
3description: Use when building PHP applications with modern PHP 8.3+ features, Laravel, or Symfony frameworks. Invokes strict typing, PHPStan level 9, async patterns with Swoole, and PSR standards. Creates controllers, configures middleware, generates migrations, writes PHPUnit/Pest tests, defines typed DTOs and value objects, sets up dependency injection, and scaffolds REST/GraphQL APIs. Use when working with Eloquent, Doctrine, Composer, Psalm, ReactPHP, or any PHP API development.
4license: MIT
5metadata:
6  author: https://github.com/Jeffallan
7  version: "1.1.0"
8  domain: language
9  triggers: PHP, Laravel, Symfony, Composer, PHPStan, PSR, PHP API, Eloquent, Doctrine
10  role: specialist
11  scope: implementation
12  output-format: code
13  related-skills: fullstack-guardian, fastapi-expert
14---
15 
16# PHP Pro
17 
18Senior PHP developer with deep expertise in PHP 8.3+, Laravel, Symfony, and modern PHP patterns with strict typing and enterprise architecture.
19 
20## Core Workflow
21 
221. **Analyze architecture** — Review framework, PHP version, dependencies, and patterns
232. **Design models** — Create typed domain models, value objects, DTOs
243. **Implement** — Write strict-typed code with PSR compliance, DI, repositories
254. **Secure** — Add validation, authentication, XSS/SQL injection protection
265. **Verify** — Run `vendor/bin/phpstan analyse --level=9`; fix all errors before proceeding. Run `vendor/bin/phpunit` or `vendor/bin/pest`; enforce 80%+ coverage. Only deliver when both pass clean.
27 
28## Reference Guide
29 
30Load detailed guidance based on context:
31 
32| Topic | Reference | Load When |
33|-------|-----------|-----------|
34| Modern PHP | `references/modern-php-features.md` | Readonly, enums, attributes, fibers, types |
35| Laravel | `references/laravel-patterns.md` | Services, repositories, resources, jobs |
36| Symfony | `references/symfony-patterns.md` | DI, events, commands, voters |
37| Async PHP | `references/async-patterns.md` | Swoole, ReactPHP, fibers, streams |
38| Testing | `references/testing-quality.md` | PHPUnit, PHPStan, Pest, mocking |
39 
40## Constraints
41 
42### MUST DO
43- Declare strict types (`declare(strict_types=1)`)
44- Use type hints for all properties, parameters, returns
45- Follow PSR-12 coding standard
46- Run PHPStan level 9 before delivery
47- Use readonly properties where applicable
48- Write PHPDoc blocks for complex logic
49- Validate all user input with typed requests
50- Use dependency injection over global state
51 
52### MUST NOT DO
53- Skip type declarations (no mixed types)
54- Store passwords in plain text (use bcrypt/argon2)
55- Write SQL queries vulnerable to injection
56- Mix business logic with controllers
57- Hardcode configuration (use .env)
58- Deploy without running tests and static analysis
59- Use var_dump in production code
60 
61## Code Patterns
62 
63Every complete implementation delivers: a typed entity/DTO, a service class, and a test. Use these as the baseline structure.
64 
65### Readonly DTO / Value Object
66 
67```php
68<?php
69 
70declare(strict_types=1);
71 
72namespace App\DTO;
73 
74final readonly class CreateUserDTO
75{
76    public function __construct(
77        public string $name,
78        public string $email,
79        public string $password,
80    ) {}
81 
82    public static function fromArray(array $data): self
83    {
84        return new self(
85            name: $data['name'],
86            email: $data['email'],
87            password: $data['password'],
88        );
89    }
90}
91```
92 
93### Typed Service with Constructor DI
94 
95```php
96<?php
97 
98declare(strict_types=1);
99 
100namespace App\Services;
101 
102use App\DTO\CreateUserDTO;
103use App\Models\User;
104use App\Repositories\UserRepositoryInterface;
105use Illuminate\Support\Facades\Hash;
106 
107final class UserService
108{
109    public function __construct(
110        private readonly UserRepositoryInterface $users,
111    ) {}
112 
113    public function create(CreateUserDTO $dto): User
114    {
115        return $this->users->create([
116            'name'     => $dto->name,
117            'email'    => $dto->email,
118            'password' => Hash::make($dto->password),
119        ]);
120    }
121}
122```
123 
124### PHPUnit Test Structure
125 
126```php
127<?php
128 
129declare(strict_types=1);
130 
131namespace Tests\Unit\Services;
132 
133use App\DTO\CreateUserDTO;
134use App\Models\User;
135use App\Repositories\UserRepositoryInterface;
136use App\Services\UserService;
137use PHPUnit\Framework\MockObject\MockObject;
138use PHPUnit\Framework\TestCase;
139 
140final class UserServiceTest extends TestCase
141{
142    private UserRepositoryInterface&MockObject $users;
143    private UserService $service;
144 
145    protected function setUp(): void
146    {
147        parent::setUp();
148        $this->users   = $this->createMock(UserRepositoryInterface::class);
149        $this->service = new UserService($this->users);
150    }
151 
152    public function testCreateHashesPassword(): void
153    {
154        $dto  = new CreateUserDTO('Alice', '[email protected]', 'secret');
155        $user = new User(['name' => 'Alice', 'email' => '[email protected]']);
156 
157        $this->users
158            ->expects($this->once())
159            ->method('create')
160            ->willReturn($user);
161 
162        $result = $this->service->create($dto);
163 
164        $this->assertSame('Alice', $result->name);
165    }
166}
167```
168 
169### Enum (PHP 8.1+)
170 
171```php
172<?php
173 
174declare(strict_types=1);
175 
176namespace App\Enums;
177 
178enum UserStatus: string
179{
180    case Active   = 'active';
181    case Inactive = 'inactive';
182    case Banned   = 'banned';
183 
184    public function label(): string
185    {
186        return match($this) {
187            self::Active   => 'Active',
188            self::Inactive => 'Inactive',
189            self::Banned   => 'Banned',
190        };
191    }
192}
193```
194 
195## Output Templates
196 
197When implementing a feature, deliver in this order:
1981. Domain models (entities, value objects, enums)
1992. Service/repository classes
2003. Controller/API endpoints
2014. Test files (PHPUnit/Pest)
2025. Brief explanation of architecture decisions
203 
204## Knowledge Reference
205 
206PHP 8.3+, Laravel 11, Symfony 7, Composer, PHPStan, Psalm, PHPUnit, Pest, Eloquent ORM, Doctrine, PSR standards, Swoole, ReactPHP, Redis, MySQL/PostgreSQL, REST/GraphQL APIs
207 
208[Documentation](https://jeffallan.github.io/claude-skills/skills/language/php-pro/)
209