@the-bearded-bear/claude-craft 3.0.0

package/Dev/i18n/de/Symfony/rules/16-i18n.md

@@ -0,0 +1,185 @@
+# Regel 09: Internationalisierung (i18n)
+
+## Unterstützte Länder
+
+**7 europäische Länder**: FR, EN, DE, ES, IT, NL, BE
+
+Jedes Land hat:
+- Seine eigene Besteuerung (MwSt)
+- Seine Formate (Daten, Zahlen, Währungen)
+- Seine Validierungen (SIRET, VAT, Postleitzahlen)
+- Seine spezifischen geschäftlichen Workflows
+
+## Country Enum
+
+```php
+enum Country: string
+{
+    case FR = 'FR';  // Frankreich
+    case EN = 'EN';  // England
+    case DE = 'DE';  // Deutschland
+    case ES = 'ES';  // Spanien
+    case IT = 'IT';  // Italien
+    case NL = 'NL';  // Niederlande
+    case BE = 'BE';  // Belgien
+
+    public function getVATRate(): float
+    {
+        return match ($this) {
+            self::FR => 0.20,
+            self::DE => 0.19,
+            self::ES => 0.21,
+            self::IT => 0.22,
+            self::NL => 0.21,
+            self::BE => 0.21,
+            self::EN => 0.20,
+        };
+    }
+
+    public function getCurrency(): Currency
+    {
+        return match ($this) {
+            self::EN => Currency::GBP,
+            default => Currency::EUR,
+        };
+    }
+}
+```
+
+## Strategy Pattern - Services pro Land
+
+```php
+// Domain Service Interface
+interface TaxCalculatorInterface
+{
+    public function calculateVAT(Money $amount): Money;
+    public function getVATRate(): TaxRate;
+}
+
+// Französische Implementierung
+final readonly class FrenchTaxCalculator implements TaxCalculatorInterface
+{
+    public function calculateVAT(Money $amount): Money
+    {
+        return $amount->multiply(0.20);
+    }
+
+    public function getVATRate(): TaxRate
+    {
+        return TaxRate::fromFloat(0.20);
+    }
+}
+
+// Deutsche Implementierung
+final readonly class GermanTaxCalculator implements TaxCalculatorInterface
+{
+    public function calculateVAT(Money $amount): Money
+    {
+        return $amount->multiply(0.19);
+    }
+
+    public function getVATRate(): TaxRate
+    {
+        return TaxRate::fromFloat(0.19);
+    }
+}
+```
+
+## Service Registry
+
+```php
+final readonly class TaxCalculatorRegistry
+{
+    public function __construct(
+        private FrenchTaxCalculator $frenchCalculator,
+        private GermanTaxCalculator $germanCalculator,
+        private SpanishTaxCalculator $spanishCalculator,
+        // ... weitere Länder
+    ) {}
+
+    public function get(Country $country): TaxCalculatorInterface
+    {
+        return match ($country) {
+            Country::FR => $this->frenchCalculator,
+            Country::DE => $this->germanCalculator,
+            Country::ES => $this->spanishCalculator,
+            Country::IT => $this->italianCalculator,
+            Country::NL => $this->dutchCalculator,
+            Country::BE => $this->belgianCalculator,
+            Country::EN => $this->englishCalculator,
+        };
+    }
+}
+```
+
+## Lokalisierte Formate
+
+### Daten
+
+```php
+final readonly class DateFormatter
+{
+    public function format(DateTimeInterface $date, Country $country): string
+    {
+        $formatter = new IntlDateFormatter(
+            $country->value,
+            IntlDateFormatter::LONG,
+            IntlDateFormatter::NONE
+        );
+
+        return $formatter->format($date);
+    }
+}
+```
+
+### Zahlen und Währungen
+
+```php
+final readonly class MoneyFormatter
+{
+    public function format(Money $money, Country $country): string
+    {
+        $formatter = new NumberFormatter(
+            $country->value,
+            NumberFormatter::CURRENCY
+        );
+
+        return $formatter->formatCurrency(
+            $money->getAmount(),
+            $money->getCurrency()->value
+        );
+    }
+}
+```
+
+## Übersetzungen
+
+```yaml
+# translations/messages.fr.yaml
+client:
+  created: "Client créé avec succès"
+  blocked: "Client bloqué"
+  validation:
+    invalid_email: "Adresse email invalide"
+
+# translations/messages.en.yaml
+client:
+  created: "Client created successfully"
+  blocked: "Client blocked"
+  validation:
+    invalid_email: "Invalid email address"
+```
+
+Verwendung:
+```php
+$this->translator->trans('client.created', [], 'messages', $locale);
+```
+
+## i18n Checkliste
+
+- [ ] Country Enum überall verwendet
+- [ ] Strategy Pattern für länderspezifische Logik
+- [ ] Lokalisierte Formate (Daten, Zahlen, Währungen)
+- [ ] Übersetzungen für alle Benutzertexte
+- [ ] Tests für jedes unterstützte Land
+- [ ] Lokale Validierung (Postleitzahlen, Identifikatoren)

package/Dev/i18n/de/Symfony/rules/17-async.md

@@ -0,0 +1,190 @@
+# Regel 10: Async-First mit Symfony Messenger
+
+## Prinzip
+
+**Jede lang laufende Operation (>500ms) MUSS asynchron sein.**
+
+Vorteile:
+- Sofortige HTTP-Antwort (UX)
+- Resilienz (automatisches Retry)
+- Horizontale Skalierbarkeit (Workers)
+- Entkopplung (SRP)
+
+## Messenger Konfiguration
+
+```yaml
+# config/packages/messenger.yaml
+framework:
+    messenger:
+        failure_transport: failed
+
+        transports:
+            async:
+                dsn: '%env(MESSENGER_TRANSPORT_DSN)%'
+                retry_strategy:
+                    max_retries: 3
+                    delay: 1000
+                    multiplier: 2
+                    max_delay: 0
+
+            failed: 'doctrine://default?queue_name=failed'
+
+        routing:
+            # Domain Events → Async
+            'App\*\Domain\*\Event\*': async
+
+            # Lange Commands → Async
+            'App\*\Application\Command\SendInvoiceCommand': async
+            'App\*\Application\Command\GeneratePdfCommand': async
+```
+
+## Message (Async Command)
+
+```php
+// Application/Command/SendInvoiceCommand.php
+
+final readonly class SendInvoiceCommand
+{
+    public function __construct(
+        public InvoiceId $invoiceId
+    ) {}
+}
+```
+
+## Message Handler
+
+```php
+// Application/Handler/SendInvoiceHandler.php
+
+#[AsMessageHandler]
+final readonly class SendInvoiceHandler
+{
+    public function __construct(
+        private InvoiceRepositoryInterface $invoiceRepository,
+        private PdfGeneratorInterface $pdfGenerator,
+        private EmailServiceInterface $emailService
+    ) {}
+
+    public function __invoke(SendInvoiceCommand $command): void
+    {
+        $invoice = $this->invoiceRepository->findById($command->invoiceId);
+
+        if ($invoice === null) {
+            throw new InvoiceNotFoundException($command->invoiceId);
+        }
+
+        // PDF-Generierung (5-10 Sekunden)
+        $pdf = $this->pdfGenerator->generate($invoice);
+
+        // E-Mail-Versand
+        $this->emailService->send(
+            to: $invoice->getClient()->getEmail(),
+            subject: 'Votre facture',
+            attachments: [$pdf]
+        );
+    }
+}
+```
+
+## Async Dispatch
+
+```php
+// In einem Controller oder State Processor
+final readonly class InvoiceProcessor
+{
+    public function __construct(
+        private MessageBusInterface $messageBus
+    ) {}
+
+    public function sendInvoice(InvoiceId $invoiceId): void
+    {
+        // Asynchroner Versand
+        $this->messageBus->dispatch(
+            new SendInvoiceCommand($invoiceId)
+        );
+
+        // SOFORTIGE Rückkehr (Versand erfolgt im Hintergrund)
+    }
+}
+```
+
+## Workers (Verarbeitung)
+
+```bash
+# Worker starten
+php bin/console messenger:consume async -vv
+
+# Produktion (supervisord)
+[program:messenger-worker]
+command=php /var/www/bin/console messenger:consume async --time-limit=3600
+numprocs=4
+autostart=true
+autorestart=true
+```
+
+## Retry Strategy
+
+```php
+// Custom Retry Strategy
+final class ExponentialBackoffRetryStrategy implements RetryStrategyInterface
+{
+    public function isRetryable(
+        Envelope $message,
+        \Throwable $throwable = null
+    ): bool {
+        // Keine Wiederholung bei Business-Fehlern
+        if ($throwable instanceof DomainException) {
+            return false;
+        }
+
+        return true;
+    }
+
+    public function getWaitingTime(
+        Envelope $message,
+        \Throwable $throwable = null
+    ): int {
+        $retries = RedeliveryStamp::getRetryCountFromEnvelope($message);
+        return 1000 * (2 ** $retries);  // 1s, 2s, 4s, 8s...
+    }
+}
+```
+
+## Monitoring
+
+```php
+// Event Subscriber für Logging
+final class MessengerEventSubscriber implements EventSubscriberInterface
+{
+    public static function getSubscribedEvents(): array
+    {
+        return [
+            WorkerMessageFailedEvent::class => 'onMessageFailed',
+            WorkerMessageHandledEvent::class => 'onMessageHandled',
+        ];
+    }
+
+    public function onMessageFailed(WorkerMessageFailedEvent $event): void
+    {
+        $this->logger->error('Message failed', [
+            'message' => $event->getEnvelope()->getMessage()::class,
+            'error' => $event->getThrowable()->getMessage(),
+        ]);
+    }
+
+    public function onMessageHandled(WorkerMessageHandledEvent $event): void
+    {
+        $this->logger->info('Message handled successfully');
+    }
+}
+```
+
+## Async Checkliste
+
+- [ ] Operationen >500ms asynchron
+- [ ] Nachrichten unveränderlich (readonly)
+- [ ] Handler mit `#[AsMessageHandler]`
+- [ ] Retry Strategy konfiguriert
+- [ ] Workers supervisord in Produktion
+- [ ] Monitoring fehlgeschlagener Nachrichten
+- [ ] Tests mit `messenger:consume --limit=1`