<?php
// src/Domain/User.php
namespace App\Domain;
readonly class User {
public function __construct(
public int $id,
public string $username,
public string $email,
public string $role = 'user',
public int $createdAt = 0,
) {}
public function toArray(): array {
return [
'id' => $this->id,
'username' => $this->username,
'email' => $this->email,
'role' => $this->role,
'created_at' => $this->createdAt,
];
}
public function withoutSensitive(): array {
$data = $this->toArray();
unset($data['password_hash']);
return $data;
}
}
<?php
// src/Domain/UserCreatedEvent.php
namespace App\Domain;
class UserCreatedEvent {
public function __construct(
public readonly User $user,
public readonly \DateTimeImmutable $occurredAt = new \DateTimeImmutable(),
) {}
}
<?php
// src/Repository/UserRepository.php
namespace App\Repository;
use App\Domain\User;
class UserRepository {
private \PDO $pdo;
public function __construct(string $dsn = 'sqlite::memory:') {
$this->pdo = new \PDO($dsn, options: [
\PDO::ATTR_ERRMODE => \PDO::ERRMODE_EXCEPTION,
\PDO::ATTR_DEFAULT_FETCH_MODE => \PDO::FETCH_ASSOC,
]);
$this->migrate();
}
private function migrate(): void {
$this->pdo->exec('CREATE TABLE IF NOT EXISTS users (
id INTEGER PRIMARY KEY AUTOINCREMENT,
username TEXT UNIQUE NOT NULL,
email TEXT UNIQUE NOT NULL,
password_hash TEXT NOT NULL,
role TEXT DEFAULT \'user\',
created_at INTEGER DEFAULT (strftime(\'%s\', \'now\'))
)');
}
public function create(string $username, string $email, string $passwordHash, string $role = 'user'): User {
$stmt = $this->pdo->prepare(
'INSERT INTO users (username, email, password_hash, role) VALUES (?, ?, ?, ?)'
);
$stmt->execute([$username, $email, $passwordHash, $role]);
return $this->findById((int)$this->pdo->lastInsertId());
}
public function findById(int $id): ?User {
$stmt = $this->pdo->prepare('SELECT * FROM users WHERE id = ?');
$stmt->execute([$id]);
$row = $stmt->fetch();
return $row ? $this->hydrate($row) : null;
}
public function findByUsername(string $username): ?array {
$stmt = $this->pdo->prepare('SELECT * FROM users WHERE username = ?');
$stmt->execute([$username]);
return $stmt->fetch() ?: null;
}
public function findAll(): array {
return array_map(
fn($row) => $this->hydrate($row),
$this->pdo->query('SELECT * FROM users ORDER BY created_at DESC')->fetchAll()
);
}
private function hydrate(array $row): User {
return new User(
id: (int)$row['id'],
username: $row['username'],
email: $row['email'],
role: $row['role'],
createdAt: (int)$row['created_at'],
);
}
}
<?php
// src/Service/AuthService.php
namespace App\Service;
use Firebase\JWT\JWT;
use Firebase\JWT\Key;
use App\Repository\UserRepository;
class AuthService {
private const ALGO = 'HS256';
public function __construct(
private UserRepository $repo,
private string $jwtSecret = 'your-secret-key-change-in-production',
private int $ttl = 3600
) {}
public function register(string $username, string $email, string $password): ?\App\Domain\User {
if ($this->repo->findByUsername($username)) {
throw new \InvalidArgumentException('Username already taken');
}
$hash = password_hash($password, PASSWORD_ARGON2ID);
return $this->repo->create($username, $email, $hash);
}
public function login(string $username, string $password): ?string {
$row = $this->repo->findByUsername($username);
if (!$row || !password_verify($password, $row['password_hash'])) {
return null;
}
$payload = [
'iss' => 'microservice',
'iat' => time(),
'exp' => time() + $this->ttl,
'sub' => $row['id'],
'username' => $row['username'],
'role' => $row['role'],
];
return JWT::encode($payload, $this->jwtSecret, self::ALGO);
}
public function verify(string $token): ?array {
try {
$decoded = JWT::decode($token, new Key($this->jwtSecret, self::ALGO));
return (array)$decoded;
} catch (\Exception) {
return null;
}
}
}
<?php
// Simple PSR-14 dispatcher (from Lab 13)
class EventDispatcher {
private array $listeners = [];
public function listen(string $event, callable $listener): void {
$this->listeners[$event][] = $listener;
}
public function dispatch(object $event): object {
foreach ($this->listeners[get_class($event)] ?? [] as $listener) {
$listener($event);
}
return $event;
}
}
// Usage in service layer
class UserService {
public function __construct(
private \App\Repository\UserRepository $repo,
private \App\Service\AuthService $auth,
private EventDispatcher $events,
) {}
public function register(string $username, string $email, string $password): array {
$user = $this->auth->register($username, $email, $password);
// Dispatch domain event
$this->events->dispatch(new \App\Domain\UserCreatedEvent($user));
return $user->toArray();
}
}
