V3 Core Implementation

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

1|Updated Jun 3, 2026
One-click install
npx skills add https://github.com/KentwareDemo/RuView --skill v3-core-implementation-kentwaredemo
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: V3 Core Implementation
Source: https://github.com/KentwareDemo/RuView/tree/main/.claude/skills/v3-core-implementation
Command: npx skills add https://github.com/KentwareDemo/RuView --skill v3-core-implementation-kentwaredemo

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill requires inversify.

What problem does it solve? Building a modular TypeScript backend without clear architectural boundaries leads to tangled code, untestable business logic, and fragile dependencies. 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, plus a full task-management domain example with entities, value objects, domain services, and events. - Repository & Use Case Patterns: Includes repository interfaces with SQLite implementations and application-layer use cases that orchestrate aggregates and publish domain events. - Dependency Injection & Testing: Configures an Inversify-based container, strict TypeScript settings, entity caching, and unit/integration test patterns. - Use Case: When scaffolding the core of claude-flow v3, use this Skill to generate the task, session, and health domains with clean dependency boundaries and over 90% test coverage targets. ## Quick Start Ask the AI to implement the core domains for claude-flow v3 following DDD patterns with entities, repositories, use cases, and comprehensive tests.

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, then organize code into bounded contexts under a domains directory. Each domain contains entities, value objects, services, repositories, and events, with use cases in an application layer orchestrating the aggregates.

How to structure a clean architecture TypeScript project?

Separate code into core domains, a shared kernel with base domain classes and infrastructure, and an application layer with use cases, commands, and queries. Use path aliases like @core and @domains in tsconfig to enforce clean import boundaries.

What dependency injection library works with TypeScript decorators?

Inversify works with TypeScript decorators when experimentalDecorators and emitDecoratorMetadata are enabled 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 entities and repositories?

Unit test entities by verifying state transitions and emitted domain events, such as checking that assigning a task changes its status and raises a TaskAssignedEvent. For repositories, run integration tests against an in-memory SQLite database to validate save and query behavior.

When should I use the repository pattern with SQLite?

Use the repository pattern when domain logic must stay independent of persistence details. Define an interface like ITaskRepository in the domain, then provide a SQLite implementation that maps database rows back to reconstituted aggregates.