Typescript Domain-Driven Design

Packages

Packages	Link
@ts-ddd/common	Go to package
@ts-ddd/entity	Go to package
@ts-ddd/state-machine	Go to package
@ts-ddd/value-object	Go to package

Common

UUID generator

1import { uuidGenerator } from '@ts-ddd/common';
2
3const uuid = uuidGenerator() // -> b9ebc3ea-bfbd-4a86-8b7b-39995b47c631

Interfaces

Interface	Properties
WithActive	isActive
WithAudit	createdBy, updatedBy and deletedBy as date
WithDomain	domain
WithLocale	locale
WithNullable	isNullable
WithOwner	ownerId
WithScope	scope
WithStatus	status
WithTimestamps	createdAt and deletedAt
WithUser	userId
WithUuid	uuid
WithVersion	version

Example

1interface Post extends WithActive, WithUuid {
2    title: string;
3    body: string;
4}
5
6/*
7  {
8    uuid: string;
9    title: string;
10    body: string;
11    isActive: boolean;
12  }
13*/

Entity

Use to create domain entities using an interface as contract.

1export interface IBook {
2  id: Identifier;
3  name: string;
4  year: number;
5  publisher: string;
6}
7

1import { uuidGenerator } from '@ts-ddd/common';
2import { Identifier, Entity } from '@ts-ddd/entity';
3import { IBook } from '../interfaces/book.interface';
4
5export class Book extends Entity<IBook> {
6  public static createToPrimitives(payload: Omit<IBook, 'id'>) {
7    return new Book({
8      id: uuidGenerator(),
9      ...payload
10    })
11  }
12  
13  public static createFromPrimitives(payload: IBook): Book {
14    return new Book(payload)
15  }
16}

Getting an object from the data source

1class BooksService {
2  constructor(private readonly booksRepository: BooksRepository) {}
3
4  public async findBookById(id: string): Promise<Book | undefined> {
5    const book = await this.booksRepository.findOne({ id });
6
7    if (book) {
8        return Book.createFromPrimitives(book)
9    }
10
11    return undefined;
12  } 
13}

Creating a book to store it in the data source

1class CreateBookUseCase {
2  constructor(private readonly booksService: BooksService) {}
3
4  public async execute(payload: Omit<IBook, 'id'>): Promise<Book | undefined> {
5    const book = await this.booksRepository.create(
6        Book.createToPrimitives(payload)
7    );
8
9    return book;
10  } 
11}

State Machine

1import { StateMachine } from '@ts-ddd/state-machine';
2
3enum LightTransitions {
4  RED = "red",
5  GREEN = "green",
6  PULSING_GREEN = "pulsing_green",
7  AMBER = "amber",
8}
9
10const transitions = {
11  [LightTransitions.RED]: [LightTransitions.GREEN],
12  [LightTransitions.GREEN]: [LightTransitions.PULSING_GREEN],
13  [LightTransitions.PULSING_GREEN]: [LightTransitions.AMBER],
14  [LightTransitions.AMBER]: [LightTransitions.RED],
15}
16
17const light = StateMachine.instance({
18  transitions,
19  currentState: LightTransitions.RED,
20});
21
22try {
23  light.setState(LightTransitions.GREEN);
24} catch (error) {
25  // InvalidStateTransitionException
26}

Value Object

1import { StringValue } from '@ts-ddd/value-object'
2import { validate, v4 as uuid } from 'uuid';
3
4export class Uuid extends StringValue {
5  constructor(value: string) {
6    super(value);
7    this.ensureIsValidUuid(value);
8  }
9
10  static generate(): Uuid {
11    return new Uuid(uuid());
12  }
13
14  private ensureIsValidUuid(value: string): void {
15    if (!validate(value)) {
16      throw new Error(`${value} is not a valid UUID`)
17    }
18  }
19}

1import { StringValue } from '@ts-ddd/value-object'
2
3export class Title extends StringValue {}

1import { PositiveNumberValue } from '@ts-ddd/value-object'
2
3export class Year extends PositiveNumberValue {}

1class BooksRepository {
2  public async getBook(id: string): Promise<Book | undefined> {
3    const book = await this.booksRepository.findOne({ id });
4
5    if (!book) {
6      return undefined;
7    }
8
9    return Book.createFromPrimitives({
10      id: new Uuid(book.id),
11      title: new Title(book.title),
12      year: new Year(book.year)
13    })
14  }
15}

---