Fähigkeiten ddd-tactical-patterns
📦

ddd-tactical-patterns

Sicher

Wende DDD-Tactical-Patterns auf deinen Code an

Schwierigkeiten, Domänenregeln in saubere Code-Strukturen zu übersetzen? Diese Fähigkeit leitet dich durch DDD-Tactical-Patterns einschließlich Entitäten, Value Objects, Aggregates, Repositories und Domänenereignisse.

Unterstützt: Claude Codex Code(CC)
🥉 74 Bronze
1

Die Skill-ZIP herunterladen

2

In Claude hochladen

Gehe zu Einstellungen → Fähigkeiten → Skills → Skill hochladen

3

Einschalten und loslegen

Teste es

Verwendung von "ddd-tactical-patterns". Modelliere ein Order-Aggregate mit submit- und cancel-Operationen

Erwartetes Ergebnis:

Order-Klasse mit privatem status-Feld, submit()-Methode, die die items-Anzahl validiert und die Single-Transition-Invariante durchsetzt, und cancel()-Methode mit passenden Guard-Bedingungen. Beinhaltet Domänenereignis-Emission für OrderSubmitted und OrderCancelled.

Verwendung von "ddd-tactical-patterns". Erstelle ein Value Object für E-Mail-Adresse

Erwartetes Ergebnis:

Unveränderliche Email-Klasse mit Regex-Validierung im Konstruktor, Gleichheit durch Wertvergleich und toString()-Methode. Lehnt ungültige Formate zum Konstruktionszeitpunkt ab.

Sicherheitsaudit

Sicher
v1 • 2/24/2026

All static analysis findings are false positives. The 'external_commands' detections were Markdown backticks around code examples (e.g., `OrderSubmitted`), not actual shell execution. The 'blocker' findings for weak cryptography and system reconnaissance were triggered by documentation text, not executable code. This is a safe educational skill containing only DDD pattern guidance and TypeScript examples.

2
Gescannte Dateien
79
Analysierte Zeilen
0
befunde
1
Gesamtzahl Audits
Keine Sicherheitsprobleme gefunden
Auditiert von: claude

Qualitätsbewertung

41
Architektur
100
Wartbarkeit
87
Inhalt
50
Community
100
Sicherheit
83
Spezifikationskonformität

Was du bauen kannst

Anämische Domänenmodelle refaktorieren

Transformiere datenorientierte Klassen in verhaltensreiche Domänenobjekte, die Geschäftsregeln durchsetzen.

Neue Aggregates entwerfen

Strukturiere neuen Domänencode mit korrekten Aggregate-Grenzen und Invarianten-Durchsetzung.

Domänenereignisse implementieren

Füge ereignisgesteuerte Kommunikation zwischen Aggregates mittels Vergangenheitsform-Domänenereignissen hinzu.

Probiere diese Prompts

Grundlegendes Aggregate-Design 
Ich muss ein Order-Aggregate modellieren. Hilf mir, die Invarianten zu identifizieren, die Entität mit Verhaltensmethoden zu entwerfen und passende Value Objects für diese Domäne zu definieren.
Value-Object-Modellierung 
Erstelle ein unveränderliches Value Object für Money mit Währung und Betrag. Füge Validierung bei Konstruktion und Gleichheit nach Wert hinzu.
Repository-Vertrags-Design 
Entwirf eine Repository-Schnittstelle für das Order-Aggregate, die domänenfreundliche Abfragemethoden bereitstellt, ohne ORM-Implementierungsdetails offenzulegen.
Domänenereignis-Implementierung 
Hilf mir, Domänenereignisse für Order-Zustandsübergänge zu definieren. Include Vergangenheitsform-Benennung, minimale Payloads und Schema-Versionierungsstrategie.

Bewährte Verfahren

  • Invariants zuerst identifizieren, dann Aggregate-Grenzen entsprechend entwerfen
  • Value Objects unveränderlich mit Validierung zum Konstruktionszeitpunkt halten
  • Domänenereignisse in Vergangenheitsform mit minimalen, stabilen Payloads benennen

Vermeiden

  • Cross-Aggregate synchrone Konsistenzregeln, die Transaktionsgrenzen verletzen
  • ORM-Entitäten in die Domänenschicht lecken lassen
  • Controller, die Domänengeschäftslogik enthalten, statt Domänenobjekte

Häufig gestellte Fragen

Wann sollte ich Aggregates gegenüber einfachen Entitäten verwenden?
Verwende Aggregates, wenn du Invarianten hast, die transaktional durchgesetzt werden müssen. Ein Aggregate Root ist der Einstiegspunkt, der Konsistenz über alle Objekte innerhalb seiner Grenze hinweg sicherstellt.
Sollten Value Objects veränderlich sein?
Nein. Value Objects sollten standardmäßig unveränderlich sein. Jede Änderung erzeugt eine neue Instanz. Dies gewährleistet Thread-Sicherheit und vereinfacht das Reasoning über den Zustand.
Wie gehe ich mit Cross-Aggregate-Kommunikation um?
Verwende Domänenereignisse für Eventual Consistency zwischen Aggregates. Vermeide synchrone Aufrufe, die Aggregates koppeln und Transaktionsgrenzen durchbrechen.
Was gehört in eine Repository-Schnittstelle?
Repository-Schnittstellen sollten domänenfreundliche Abfragemethoden bereitstellen und nur Aggregate Roots persistieren oder laden. Sie sollten keine ORM-spezifischen Implementierungsdetails offenlegen.
Wie weiß ich, ob ich Domänenereignisse brauche?
Verwende Domänenereignisse, wenn andere Teile des Systems auf Zustandsänderungen reagieren müssen, ohne enge Kopplung. Sie sind unerlässlich für Audit-Trails, Benachrichtigungen und CQRS-Muster.
Kann ich diese Fähigkeit für Microservices-Architektur verwenden?
Ja. DDD-Tactical-Patterns funktionieren gut mit Microservices. Jeder Service kann seine eigenen Aggregates haben, und Domänenereignisse können die Inter-Service-Kommunikation erleichtern.

Entwicklerdetails

Autor

sickn33

Lizenz

MIT

Repository

https://github.com/sickn33/antigravity-awesome-skills/tree/main/skills/ddd-tactical-patterns

Ref

main

Dateistruktur

📁 references/

📄 tactical-checklist.md

📄 SKILL.md