ddd-usecase-generator

moasadi's avatarfrom moasadi

Generate application layer use cases and event listeners with proper DI and orchestration. Use when adding business operations, creating workflows, or implementing event-driven logic (e.g., "Create RegisterUser use case", "Generate PlaceOrder with inventory check").

⭐2stars🔀0forks📁View on GitHub🕐Updated Oct 29, 2025

When & Why to Use This Skill

The DDD UseCase Generator is a specialized Claude skill designed to automate the creation of application layer components following Domain-Driven Design (DDD) principles. It streamlines the development of TypeScript use cases and event listeners, ensuring proper dependency injection, domain event emission, and standardized error handling. By enforcing clean architecture patterns, it helps developers maintain a scalable and decoupled codebase while significantly reducing boilerplate for business logic orchestration.

Use Cases

  • Implementing complex business workflows: Quickly generate use cases like 'PlaceOrder' that require orchestrating multiple repositories, inventory checks, and payment processing.
  • Building event-driven architectures: Automatically create event listeners to handle domain events, such as sending a welcome email after a 'UserRegistered' event is emitted.
  • Standardizing application layer logic: Ensure all business operations follow a consistent pattern with single-responsibility classes, 'execute()' methods, and proper input/output validation.
  • Rapid CRUD scaffolding: Accelerate the development of standard Create, Find, Update, and Delete operations for new domain entities while adhering to strict architectural boundaries.
  • Refactoring legacy logic into DDD: Use the generator to wrap existing business logic into clean, injectable use case classes with proper dependency management.
nameddd-usecase-generator
descriptionGenerate application layer use cases and event listeners with proper DI and orchestration. Use when adding business operations, creating workflows, or implementing event-driven logic (e.g., "Create RegisterUser use case", "Generate PlaceOrder with inventory check").
allowed-toolsRead, Write, Edit, Glob, Grep

DDD UseCase Generator

Generate application layer use cases and event listeners with proper dependency injection, domain event emission, and orchestration logic.

What This Skill Does

Creates application layer components that orchestrate domain logic:

  • Use Cases: Single-responsibility classes with execute() method
  • Event Listeners: Handlers for domain events
  • Proper DI: tsyringe decorators and injection patterns
  • Event Emission: Domain event publishing after operations
  • Error Handling: Domain error propagation

When to Use This Skill

Use when you need to:

  • Add new business operations to existing context
  • Create complex workflows orchestrating multiple entities
  • Implement event-driven logic
  • Add CRUD operations for entities

Examples:

  • "Create a RegisterUser use case with email verification"
  • "Generate a PlaceOrder use case with inventory check"
  • "Add a ProcessPayment use case with transaction handling"

UseCase Pattern

import { inject, injectable } from 'tsyringe';
import type { IEntityRepository } from '@/contexts/context/domain';
import { EntityNotFoundError } from '@/contexts/context/domain';
import { eventBus } from '@/global/events/event-bus';
import { EntityCreated } from '@/contexts/context/domain';

export interface ExecuteInput {
  field1: string;
  field2: number;
}

export interface ExecuteOutput {
  id: string;
  field1: string;
  field2: number;
}

@injectable()
export class ActionEntityUseCase {
  constructor(
    @inject('IEntityRepository')
    private readonly entityRepo: IEntityRepository,

    @inject(OtherUseCase)
    private readonly otherUseCase: OtherUseCase
  ) {}

  async execute(input: ExecuteInput): Promise<ExecuteOutput> {
    this.validateInput(input);

    const entity = await this.entityRepo.findById(input.id);
    if (!entity) {
      throw new EntityNotFoundError(input.id);
    }

    entity.performBusinessLogic(input.field1);

    await this.entityRepo.save(entity);

    await eventBus.emit('EntityCreated', new EntityCreated(
      entity.getId(),
      entity.getField1()
    ));

    return this.toOutput(entity);
  }

  private validateInput(input: ExecuteInput): void {
    if (!input.field1) {
      throw new InvalidDataError('Field1 required');
    }
  }

  private toOutput(entity: Entity): ExecuteOutput {
    return {
      id: entity.getId(),
      field1: entity.getField1(),
      field2: entity.getField2(),
    };
  }
}

Event Listener Pattern

import { inject, injectable } from 'tsyringe';
import type { EntityCreated } from '@/contexts/context/domain';
import type { IRelatedRepository } from '@/contexts/related/domain';

@injectable()
export class EntityCreatedListener {
  constructor(
    @inject('IRelatedRepository')
    private readonly relatedRepo: IRelatedRepository
  ) {}

  async handle(event: EntityCreated): Promise<void> {
    try {
      await this.performAction(event);
    } catch (error) {
      console.error('Error handling EntityCreated:', error);
    }
  }

  private async performAction(event: EntityCreated): Promise<void> {
    // Listener logic
  }
}

Dependency Injection Rules

Repositories: Inject by string token

constructor(
  @inject('IUserRepository')
  private readonly userRepo: IUserRepository
) {}

Use Cases: Inject by class

constructor(
  @inject(OtherUseCase)
  private readonly otherUseCase: OtherUseCase
) {}

Services: Inject by token or class depending on type

Common Use Case Types

Create Use Case

@injectable()
export class CreateEntityUseCase {
  constructor(
    @inject('IEntityRepository')
    private readonly repo: IEntityRepository
  ) {}

  async execute(input: CreateInput): Promise<CreateOutput> {
    this.validateInput(input);

    const entity = Entity.create({
      field1: input.field1,
      field2: input.field2,
    });

    await this.repo.save(entity);

    await eventBus.emit('EntityCreated', new EntityCreated(
      entity.getId()
    ));

    return this.toOutput(entity);
  }
}

Find Use Case

@injectable()
export class FindEntityUseCase {
  constructor(
    @inject('IEntityRepository')
    private readonly repo: IEntityRepository
  ) {}

  async execute(id: string): Promise<FindOutput> {
    const entity = await this.repo.findById(id);

    if (!entity) {
      throw new EntityNotFoundError(id);
    }

    return this.toOutput(entity);
  }
}

Update Use Case

@injectable()
export class UpdateEntityUseCase {
  constructor(
    @inject('IEntityRepository')
    private readonly repo: IEntityRepository
  ) {}

  async execute(input: UpdateInput): Promise<UpdateOutput> {
    const entity = await this.repo.findById(input.id);
    if (!entity) {
      throw new EntityNotFoundError(input.id);
    }

    entity.updateField(input.field);

    await this.repo.save(entity);

    await eventBus.emit('EntityUpdated', new EntityUpdated(
      entity.getId()
    ));

    return this.toOutput(entity);
  }
}

Delete Use Case

@injectable()
export class DeleteEntityUseCase {
  constructor(
    @inject('IEntityRepository')
    private readonly repo: IEntityRepository
  ) {}

  async execute(id: string): Promise<void> {
    const exists = await this.repo.exists(id);
    if (!exists) {
      throw new EntityNotFoundError(id);
    }

    await this.repo.delete(id);

    await eventBus.emit('EntityDeleted', new EntityDeleted(id));
  }
}

Critical Rules

MUST DO:

  • Add @injectable() decorator
  • Inject repositories with string tokens
  • Inject use cases by class
  • Single public execute() method
  • Define input/output interfaces
  • Validate input
  • Emit domain events after success
  • Throw domain errors (not HTTP exceptions)
  • Return plain objects (not entities)

MUST NOT:

  • Forget @injectable() decorator
  • Mix injection patterns (token vs class)
  • Include HTTP concerns (status codes)
  • Put business logic in use case (belongs in entity)
  • Return domain entities directly
  • Skip input validation
  • Throw HTTP exceptions

Generated Files

/src/contexts/{Context}/application/
├── usecases/
│   ├── create-{entity}.usecase.ts
│   ├── find-{entity}.usecase.ts
│   ├── find-all-{entity}.usecase.ts
│   ├── update-{entity}.usecase.ts
│   └── delete-{entity}.usecase.ts
├── listeners/
│   └── {event}.listener.ts
└── index.ts

Integration

Update Application Barrel Export

// application/index.ts
export * from './usecases/create-entity.usecase';
export * from './usecases/find-entity.usecase';
export * from './usecases/update-entity.usecase';
export * from './usecases/delete-entity.usecase';
export * from './listeners/entity-created.listener';

Register Event Listener

Add to /src/main.ts:

import { EntityCreatedListener } from '@/contexts/entity/application';

const listener = container.resolve(EntityCreatedListener);
eventBus.on('EntityCreated', listener.handle.bind(listener));

Validation Checklist

After generation, verify:

  • All use cases have @injectable()
  • Repositories injected with string tokens
  • Use cases injected by class
  • Single execute() method present
  • Input/output interfaces defined
  • Input validation implemented
  • Domain events emitted after success
  • Domain errors thrown (not HTTP)
  • Returns plain objects
  • Event listeners have @injectable()
  • Listeners have handle() method
  • Listeners catch and log errors
  • ddd-context-generator: Generate complete context
  • ddd-entity-generator: Generate entities used by use cases
  • ddd-api-generator: Generate controllers that call use cases
  • di-helper: Check DI registration