dddts

TypeScript building blocks for Domain-Driven Design (DDD) tactical patterns.

Installation

npm install ddd-typescript

Features

• Entity: Objects defined by identity rather than attributes
• Value Object: Immutable objects defined by their attributes
• Aggregate Root: Cluster of entities and value objects with a consistency boundary
• Domain Events: Event-driven architecture support with an in-process broker

Usage

Entity

import { AbstractEntity } from "ddd-typescript";

type UserProps = {
  id?: string;
  name: string;
  email: string;
};

class User extends AbstractEntity<UserProps> {
  get name() {
    return this._data.name;
  }

  get email() {
    return this._data.email;
  }
}

const user = new User({ name: "John", email: "[email protected]" });
console.log(user.id); // Auto-generated UUID

Value Object

import { ValueObject } from "ddd-typescript";

type EmailProps = {
  value: string;
};

class Email extends ValueObject<EmailProps> {
  constructor(email: string) {
    super({ value: email });
  }

  get address() {
    return this._data.value;
  }
}

const email1 = new Email("[email protected]");
const email2 = new Email("[email protected]");
console.log(email1.equals(email2)); // true

Aggregate Root with Domain Events

import {
  AbstractAggregateRoot,
  AbstractDomainEvent,
  DomainEventsBroker,
} from "ddd-typescript";

class UserCreatedEvent extends AbstractDomainEvent<{ email: string }> {}

type UserProps = {
  id?: string;
  email: string;
};

class User extends AbstractAggregateRoot<UserProps> {
  static create(email: string) {
    const user = new User({ email });
    user.addDomainEvent(
      new UserCreatedEvent({ aggregateId: user.id }, { email }),
    );
    return user;
  }

  get email() {
    return this._data.email;
  }
}

// Register event handler
DomainEventsBroker.registerEventHandler("UserCreatedEvent", (event) => {
  console.log("User created:", event.data);
});

const user = User.create("[email protected]");
DomainEventsBroker.dispatchAggregateEvents(user);

API Reference

AbstractEntity

Base class for entities with identity-based equality.

• id: string - Unique identifier (auto-generated UUID)
• equals(object?: Entity): boolean - Compare entities by identity

ValueObject

Base class for value objects with attribute-based equality.

• value: T - Immutable data
• equals(vo?: ValueObject<T>): boolean - Compare by shallow equality

AbstractAggregateRoot

Base class for aggregate roots with domain event support.

• domainEvents: DomainEvent[] - Array of pending domain events
• addDomainEvent(event: DomainEvent): void - Add event to aggregate
• clearDomainEvents(): void - Clear all events

DomainEventsBroker

In-process message broker for domain events.

• registerEventHandler(eventName: string, handler: DomainEventHandler): void - Register handler
• registerAggregate(aggregate: AggregateRoot): void - Register aggregate for dispatch
• dispatchAggregateEvents(aggregate: AggregateRoot): void - Dispatch aggregate events
• clearEventHandlers(): void - Clear all handlers
• clearRegisteredAggregates(): void - Clear all registered aggregates

Development

# Install dependencies
npm install

# Build
npm run build

# Run tests
npm test

# Type check
npm run typecheck

# Watch mode
npm run dev

License

ISC