autoworkflow 3.1.5 → 3.5.0

package/.claude/skills/php.md

@@ -0,0 +1,398 @@
+# PHP Skill (PHP 8.2+)
+
+## Constructor Property Promotion
+\`\`\`php
+<?php
+
+declare(strict_types=1);
+
+// Modern PHP 8+ syntax
+readonly class User
+{
+    public function __construct(
+        public string $id,
+        public string $email,
+        public string $name,
+        public bool $isActive = true,
+        public ?DateTimeImmutable $createdAt = null,
+    ) {
+        $this->createdAt ??= new DateTimeImmutable();
+    }
+}
+
+// Service with dependency injection
+final readonly class UserService
+{
+    public function __construct(
+        private UserRepositoryInterface $repository,
+        private PasswordHasherInterface $hasher,
+        private LoggerInterface $logger,
+    ) {}
+
+    public function findById(string $id): ?User
+    {
+        return $this->repository->find($id);
+    }
+}
+\`\`\`
+
+## Enums
+\`\`\`php
+<?php
+
+// Backed enum
+enum UserStatus: string
+{
+    case Active = 'active';
+    case Pending = 'pending';
+    case Suspended = 'suspended';
+    case Deleted = 'deleted';
+
+    public function label(): string
+    {
+        return match($this) {
+            self::Active => 'Active User',
+            self::Pending => 'Awaiting Verification',
+            self::Suspended => 'Account Suspended',
+            self::Deleted => 'Account Deleted',
+        };
+    }
+
+    public function canLogin(): bool
+    {
+        return $this === self::Active;
+    }
+}
+
+// Usage
+$status = UserStatus::Active;
+$status->value;  // 'active'
+$status->label(); // 'Active User'
+
+// From string
+$status = UserStatus::from('active');  // Throws if invalid
+$status = UserStatus::tryFrom('invalid');  // Returns null
+\`\`\`
+
+## Attributes
+\`\`\`php
+<?php
+
+use Attribute;
+
+// Define attribute
+#[Attribute(Attribute::TARGET_PROPERTY)]
+final readonly class Validate
+{
+    public function __construct(
+        public string $rule,
+        public ?string $message = null,
+    ) {}
+}
+
+#[Attribute(Attribute::TARGET_METHOD)]
+final readonly class Route
+{
+    public function __construct(
+        public string $path,
+        public string $method = 'GET',
+        public array $middleware = [],
+    ) {}
+}
+
+// Usage
+final class UserController
+{
+    #[Route('/users/{id}', 'GET')]
+    public function show(string $id): JsonResponse
+    {
+        // ...
+    }
+
+    #[Route('/users', 'POST', middleware: ['auth'])]
+    public function store(Request $request): JsonResponse
+    {
+        // ...
+    }
+}
+
+// DTO with validation attributes
+final readonly class CreateUserRequest
+{
+    public function __construct(
+        #[Validate('email', 'Invalid email format')]
+        public string $email,
+
+        #[Validate('min:2|max:100')]
+        public string $name,
+
+        #[Validate('min:8')]
+        public string $password,
+    ) {}
+}
+\`\`\`
+
+## Match Expressions
+\`\`\`php
+<?php
+
+// Match expression (exhaustive, returns value)
+$message = match($status) {
+    UserStatus::Active => 'Welcome back!',
+    UserStatus::Pending => 'Please verify your email',
+    UserStatus::Suspended => 'Account suspended',
+    UserStatus::Deleted => 'Account not found',
+};
+
+// With conditions
+$discount = match(true) {
+    $total >= 1000 => 0.20,
+    $total >= 500 => 0.15,
+    $total >= 100 => 0.10,
+    default => 0,
+};
+
+// Multiple conditions
+$category = match($code) {
+    200, 201, 204 => 'success',
+    400, 401, 403, 404 => 'client_error',
+    500, 502, 503 => 'server_error',
+    default => 'unknown',
+};
+\`\`\`
+
+## Null Safety and Error Handling
+\`\`\`php
+<?php
+
+// Nullsafe operator
+$country = $user?->address?->country?->name;
+
+// Null coalescing
+$name = $user->name ?? 'Anonymous';
+$name ??= 'Default';  // Assignment
+
+// Named arguments
+$user = new User(
+    id: Uuid::uuid4()->toString(),
+    email: $email,
+    name: $name,
+    isActive: false,
+);
+
+// Result pattern for expected failures
+final readonly class Result
+{
+    private function __construct(
+        public bool $success,
+        public mixed $value = null,
+        public ?Error $error = null,
+    ) {}
+
+    public static function success(mixed $value): self
+    {
+        return new self(success: true, value: $value);
+    }
+
+    public static function failure(Error $error): self
+    {
+        return new self(success: false, error: $error);
+    }
+
+    public function isSuccess(): bool
+    {
+        return $this->success;
+    }
+
+    public function getOrThrow(): mixed
+    {
+        if (!$this->success) {
+            throw new RuntimeException($this->error->message);
+        }
+        return $this->value;
+    }
+}
+
+// Usage
+public function createUser(CreateUserRequest $request): Result
+{
+    if ($this->repository->existsByEmail($request->email)) {
+        return Result::failure(new Error('email_taken', 'Email already exists'));
+    }
+
+    $user = new User(
+        id: Uuid::uuid4()->toString(),
+        email: $request->email,
+        name: $request->name,
+    );
+
+    $this->repository->save($user);
+
+    return Result::success($user);
+}
+\`\`\`
+
+## Collections
+\`\`\`php
+<?php
+
+// Array functions with arrow functions
+$emails = array_map(fn(User $u) => $u->email, $users);
+
+$active = array_filter($users, fn(User $u) => $u->isActive);
+
+$total = array_reduce(
+    $items,
+    fn(float $sum, Item $item) => $sum + $item->price,
+    0.0
+);
+
+// Using Collection class (Laravel or custom)
+$users = collect($users)
+    ->filter(fn(User $u) => $u->isActive)
+    ->map(fn(User $u) => new UserDto($u))
+    ->sortByDesc(fn(UserDto $u) => $u->createdAt)
+    ->values()
+    ->all();
+
+// Generator for large datasets
+function processUsers(iterable $users): Generator
+{
+    foreach ($users as $user) {
+        yield processUser($user);
+    }
+}
+\`\`\`
+
+## Interfaces and Traits
+\`\`\`php
+<?php
+
+// Interface
+interface UserRepositoryInterface
+{
+    public function find(string $id): ?User;
+    public function findByEmail(string $email): ?User;
+    public function save(User $user): void;
+    public function delete(string $id): void;
+}
+
+// Trait for common functionality
+trait Timestamps
+{
+    public ?DateTimeImmutable $createdAt = null;
+    public ?DateTimeImmutable $updatedAt = null;
+
+    public function touch(): void
+    {
+        $this->updatedAt = new DateTimeImmutable();
+    }
+
+    public function setCreatedAt(): void
+    {
+        $this->createdAt ??= new DateTimeImmutable();
+    }
+}
+
+// Usage
+class Post
+{
+    use Timestamps;
+
+    public function __construct(
+        public string $id,
+        public string $title,
+        public string $content,
+    ) {
+        $this->setCreatedAt();
+    }
+}
+\`\`\`
+
+## Testing with PHPUnit
+\`\`\`php
+<?php
+
+use PHPUnit\\Framework\\TestCase;
+use PHPUnit\\Framework\\Attributes\\Test;
+use PHPUnit\\Framework\\Attributes\\DataProvider;
+
+final class UserServiceTest extends TestCase
+{
+    private UserRepositoryInterface $repository;
+    private UserService $service;
+
+    protected function setUp(): void
+    {
+        $this->repository = $this->createMock(UserRepositoryInterface::class);
+        $this->service = new UserService($this->repository);
+    }
+
+    #[Test]
+    public function findsUserById(): void
+    {
+        $user = new User(id: '1', email: 'test@example.com', name: 'Test');
+
+        $this->repository
+            ->expects($this->once())
+            ->method('find')
+            ->with('1')
+            ->willReturn($user);
+
+        $result = $this->service->findById('1');
+
+        $this->assertSame($user, $result);
+    }
+
+    #[Test]
+    public function returnsNullWhenUserNotFound(): void
+    {
+        $this->repository
+            ->method('find')
+            ->willReturn(null);
+
+        $result = $this->service->findById('999');
+
+        $this->assertNull($result);
+    }
+
+    #[Test]
+    #[DataProvider('invalidEmailProvider')]
+    public function rejectsInvalidEmails(string $email): void
+    {
+        $this->expectException(ValidationException::class);
+
+        $this->service->create(new CreateUserRequest(
+            email: $email,
+            name: 'Test',
+            password: 'password123',
+        ));
+    }
+
+    public static function invalidEmailProvider(): array
+    {
+        return [
+            'empty' => [''],
+            'no at sign' => ['invalid'],
+            'no domain' => ['test@'],
+        ];
+    }
+}
+\`\`\`
+
+## ✅ DO
+- Use \`declare(strict_types=1)\` in all files
+- Use \`readonly\` classes for immutable data
+- Use constructor property promotion
+- Use enums for fixed sets of values
+- Use match expressions instead of switch
+- Use attributes for metadata
+- Follow PSR-12 coding standards
+
+## ❌ DON'T
+- Don't use \`@var\` annotations when types are declared
+- Don't use arrays for typed data (use DTOs/value objects)
+- Don't use \`mixed\` when specific types are possible
+- Don't suppress errors with \`@\`
+- Don't use globals or static state
+- Don't catch \`Exception\` without rethrowing or logging