drn-sharedkernel

Provide domain primitives and patterns for domain-driven architectures.

20|3|Updated Aug 13, 2023
One-click install
npx skills add https://github.com/duranserkan/DRN-Project --skill drn-sharedkernel
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: drn-sharedkernel
Source: https://github.com/duranserkan/DRN-Project/tree/main/.agent/skills/drn-sharedkernel
Command: npx skills add https://github.com/duranserkan/DRN-Project --skill drn-sharedkernel

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

DRN.Framework.SharedKernel provides foundational domain primitives and patterns to support robust domain-driven design, preventing duplication of core domain concerns across projects.

Core Features & Use Cases

  • Domain primitives: Entity, AggregateRoot, DomainEvent, and repository contracts to model rich domain behavior.
  • Consistent conventions: JSON serialization, AppConstants, and exception hierarchy to standardize cross-cutting concerns.
  • Reuse across layers: Safe sharing of primitives between Contract, Domain, and API layers to accelerate development.

Quick Start

Create a simple domain model by deriving an entity from SourceKnownEntity, define an AggregateRoot, and implement a repository using ISourceKnownRepository.

Frequently Asked Questions about drn-sharedkernel

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

FAQPage Schema
How do I implement domain-driven design primitives like aggregate roots and entities?

Domain-driven design primitives are implemented by deriving entities from a base class, defining aggregate roots, and implementing repository contracts to model rich domain behavior while preventing duplication of core domain concerns across projects.

What are the foundational domain patterns needed for robust domain-driven architectures?

Foundational domain patterns include entities, aggregate roots, domain events, and repository contracts. These primitives model rich domain behavior and enforce consistent conventions for IDs, JSON serialization, pagination, and exception handling across layers.

How do I standardize JSON serialization and exception handling across domain layers?

Standardize JSON serialization and exception handling by reusing foundational domain primitives and shared conventions across Contract, Domain, and API layers, ensuring consistent cross-cutting concerns and accelerating development.

Can I share domain primitives between Contract, Domain, and API layers?

Yes, you can safely share domain primitives between Contract, Domain, and API layers. This reuse accelerates development and enforces consistent conventions for IDs, JSON serialization, and exception handling across the architecture.

How do I create a domain model with an aggregate root and repository?

Create a domain model by deriving an entity from a base entity class, defining an aggregate root, and implementing a repository using repository contracts to establish rich domain behavior and consistent conventions.

When do I need domain events and repository contracts in domain-driven design?

You need domain events and repository contracts when modeling rich domain behavior in domain-driven design. These foundational patterns support robust architectures by standardizing cross-cutting concerns and enabling safe reuse across layers.