V3 Core Implementation

Implements DDD domains, clean architecture, and dependency injection for TypeScript core modules.

Updated May 8, 2026
One-click install
npx skills add https://github.com/FrekiManagarm/d-chambaud --skill v3-core-implementation-frekimanagarm
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: V3 Core Implementation
Source: https://github.com/FrekiManagarm/d-chambaud/tree/main/.agents/skills/v3-core-implementation
Command: npx skills add https://github.com/FrekiManagarm/d-chambaud --skill v3-core-implementation-frekimanagarm

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill requires inversify.

What problem does it solve? Building a modular TypeScript codebase without clear architectural boundaries leads to tangled dependencies, untestable business logic, and fragile domain models. This Skill provides a complete blueprint for implementing core modules using Domain-Driven Design, clean architecture, and dependency injection. ## Core Features & Use Cases - DDD Domain Modeling: Provides base classes for entities, value objects, and aggregate roots with domain event support, plus a full task management domain example. - Clean Architecture Layers: Defines repository interfaces with SQLite implementations, application use cases with command handling, and an Inversify-based dependency injection container. - Testing & Quality: Includes unit and integration test patterns, strict TypeScript configuration, and entity caching for performance. - Use Case: When bootstrapping a new TypeScript backend service, use this Skill to scaffold bounded contexts (task, session, health domains) with entities, repositories, use cases, and tests following consistent DDD patterns. ## Quick Start Ask the AI to implement the core domains for Codex-flow v3 with DDD patterns, dependency injection, and comprehensive test coverage.

Frequently Asked Questions about V3 Core Implementation

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

FAQPage Schema
How do I implement Domain-Driven Design in TypeScript?▼

Start with base classes for Entity, ValueObject, and AggregateRoot that handle identity equality and domain events. Then organize code into bounded contexts with entities, value objects, services, and repositories per domain, keeping domain logic free of infrastructure dependencies.

How to structure a clean architecture TypeScript project?▼

Separate code into domain, application, and infrastructure layers. The domain layer holds entities and business rules, the application layer contains use cases and command handlers, and infrastructure provides repository implementations, event buses, and loggers wired through a DI container.

What dependency injection library works with TypeScript decorators?▼

Inversify works with TypeScript decorators when you enable experimentalDecorators and emitDecoratorMetadata in tsconfig. Bind interfaces to implementations in a container using symbols as service identifiers, then resolve dependencies through constructor injection.

How do I test DDD domain entities in isolation?▼

Test entities as plain unit tests without databases by asserting state changes and emitted domain events after method calls. Use in-memory SQLite databases for repository integration tests to verify mapping between rows and reconstituted aggregates.

When should I use domain events in an aggregate root?▼

Raise domain events inside aggregate methods when significant state changes occur, such as task assignment or completion. Collect uncommitted events on the aggregate, publish them after persistence succeeds in the use case, then mark them committed.