ddd-usage

Model domain primitives and publish CloudEvent-compatible domain events via Dapr.

1|Updated Mar 16, 2024
One-click install
npx skills add https://github.com/tdcare/genies --skill ddd-usage
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: ddd-usage
Source: https://github.com/tdcare/genies/tree/main/.qoder/skills/ddd-usage
Command: npx skills add https://github.com/tdcare/genies --skill ddd-usage

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Genies DDD primitives provide a minimal, type-safe foundation for aggregates, domain events, and event publishing, simplifying domain modeling and ensuring consistent event delivery with an Outbox pattern.

Core Features & Use Cases

  • Aggregate and DomainEvent traits with derive macros for ergonomic domain modeling
  • publish and publishGenericDomainEvent functions to emit CloudEvent-compatible messages
  • Outbox-based persistence and Dapr Pub/Sub integration for reliable delivery
  • CloudEvent compatibility and seamless integration with genies_derive

Quick Start

Define an aggregate using #[derive(Aggregate)] and a domain event using #[derive(DomainEvent)], then publish events with the provided publish functions.

Frequently Asked Questions about ddd-usage

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I implement domain events and aggregates in Rust for microservices?

You can model aggregates and domain events in Rust by deriving the Aggregate and DomainEvent traits, then using publish functions to emit CloudEvent-compatible messages for reliable microservice communication.

What is the Outbox pattern for publishing domain events in DDD?

The Outbox pattern ensures reliable domain event delivery by persisting events locally before publishing them, preventing data inconsistency between aggregate state changes and event emission across distributed services.

How do I send CloudEvent-compatible messages using Dapr Pub/Sub in Rust?

You can send CloudEvent-compatible messages in Rust by using the publish and publishGenericDomainEvent functions, which provide seamless Dapr Pub/Sub integration for reliable event-driven architecture.

Does this DDD framework require specific Rust crates for domain modeling?

Yes, it requires the genies_ddd and genies_derive crates to define aggregates and domain events using provided traits and derive macros for ergonomic, type-safe domain modeling.

What is the best way to ensure aggregate and domain event consistency across microservices?

Using an Outbox-based delivery path with Dapr Pub/Sub integration ensures aggregate state changes and domain event publishing remain consistent across distributed microservices.