SOLID z przykładami w TypeScript

SOLID (Single responsibility principle, Open/closed principle, Liskov substitution principle, Interface segregation principle, Dependency inversion principle), czyli pięć zasad programowania obiektowego, które każdy powinien przestrzegać.

SOLIDny kod

Co to jest SOLID?

Zasada pojedynczej odpowiedzialności (SRP)

export class Post {
  constructor(
    private readonly id: PostId,
    private readonly title: string,
    private readonly content: string,
    private readonly categoryName: string,
    private readonly categoryDescription: string,
    private readonly categoryId: string,
    private readonly visible = true,
  ) {}

  toggleVisibility() {
    this.visible = !this.visible;
  }

  changeCategory(dto: CategoryDto) {
    this.categoryName = dto.name;
    this.categoryDescription= dto.description;
    this.categoryId = dto.id;
  }

  categoryIs(categorySlug: string): boolean {
    return this.categorySlug === categorySlug;
  }
}

export class Category {
  constructor(
    private readonly id: CategoryId,
    private readonly name: string,
    private readonly description: string,
  ) {}

  update(dto: CategoryDto) {
    this.name = dto.name;
    this.description = dto.description;
  }
}

export class Post {
  constructor(
    private readonly id: PostId,
    private readonly title: string,
    private readonly content: string,
    private readonly categoryId: CategoryId,
    private readonly visible = true,
  ) {}

  toggleVisibility() {
    this.visible = !this.visible;
  }

  changeCategory(categoryId: CategoryId) {
    this.categoryId = categoryId;
  }

  categoryIs(categoryId: CategoryId): boolean {
    return this.categoryId === categoryId;
  }
}

Zasada otwarte-zamknięte (OCP)

export class Product {
  constructor(
    private readonly id: ProductId,
    private readonly name: string,
    private readonly basePrice: Price,
    private readonly category: Category,
  ) {}

  calculatePrice(season: PricingSeason): Price {
    const price = this.basePrice;

    if (this.category.giftable() && season.preGiftable()) {
      price = price.percentageIncrease(15);
    } 

    if (this.category.giftable() && season.giftable()) {
      price = price.percentageDecrease(5);
    } 

    if (this.category.giftable() && season.postGiftable()) {
      price = price.percentageDecrease(10);
    } 

    if (this.category.excisable()) {
      price = price.percentageIncrease(5);
    } 

    return price;
  }
}

export interface ProductPricePolicy {
  calculate(season: PricingSeason, category: Category, base: Price): Price;
}

export class PreGiftablePricePolicy {
  calculate(season: PricingSeason, category: Category, base: Price): Price {
    return category.giftable() && season.preGiftable() 
        ? price.percentageIncrease(15)
        : price;
  }
}

export class Product {
  constructor(
    private readonly id: ProductId,
    private readonly name: string,
    private readonly basePrice: Price,
    private readonly category: Category,
  ) {}

  calculatePrice(season: PricingSeason, policies: ProductPricePolicy[]): Price {
    return policies.reduce(
       (price: Price, policy: ProductPricePolicy) => policy.calculate(season, this.category, price), 
       this.basePrice
    );
  }
}

Zasada podstawienia Barbary Liskov (LSP)

export abstract class BlogMedia {
  // other logic 

  abstract toPDF(): PDF;
}

export class Post extends BlogMedia {
  toPDF(): PDF {
    return this.pdfConverter.convert(
      this.toPayload()
    );
  }
}

export class Movie extends BlogMedia {
  toPDF(): PDF {
    throw new Error('Movie cannot be converted to PDF file!');
  }
}

export class BlogMediaService {
  convertToPDF(mediaId: string): PDF {
    const media: BlodMedia = this.mediaRepository.find(mediaId);

    return media.toPDF();
  }
}

export abstract class BlogMedia {
  // other logic 
}

export interface class BlogMediaConvertableToPDF {
  getBlogMediaPDFPayload(): BlogMediaPDFPayload;
}

export class Post extends BlogMedia implements ConvertableToPDF {
  getBlogMediaPDFPayload(): BlogMediaPDFPayload {
    return {
      name: this.title,
      language: this.language,
      content: this.content,
    };
  }
}

export class Movie extends BlogMedia {
  // other logic 
}

export class BlogMediaService {
  convertToPDF(media: BlogMediaConvertableToPDF, converter: PDFConverter): PDF {
    return converter.convert(
      media.getBlogMediaPDFPayload()
    );
  }
}

Zasada segregacji interfejsów (ISP)

export interface Convertable {
  toPDF(): PDF;
  toDOC(): DOC;
  toHTML(): HTML;
  toTXT(): TXT;
}

export class Post implements Convertable {
  // implementations
}

export interface ConvertableToPDF {
  toPDF(): PDF;
}

// ...

export interface ConvertableToTXT {
  toTXT(): TXT;
}

export class Post implements ConvertableToPDF, ConvertableToDOC, ConvertableToHTML, ConvertableToTXT {
  // implementations
}

export class AccessLog implements ConvertableToTXT {
  // implementation
}

Zasada odwrócenia zależności (DIP)

export class BlogPostsService {
  constructor(
    private readonly repository: BlogPostRepository,
  ) {}

  remove(id: string) {
    const post = this.repository.findOrFail(id);

    this.repository.remove(post)
  }
}

export interface BlogPostRepositoryInterface {
  findOrFail(id: string): BlogPost;
  remove(post: BlogPost);
}

export class BlogPostsService {
  constructor(
    private readonly repository: BlogPostRepositoryInterface,
  ) {}

  remove(id: string) {
    const post = this.repository.findOrFail(id);

    this.repository.remove(post)
  }
}

Podsumowanie

Polecane wpisy:

Autor wpisu:

Gabriel Ślawski

Fanatyk czystego i prostego kodu. Zwolennik podejść DDD oraz Modular Monolith. Na codzień pracuje jako programista i architekt. Po godzinach spełnia się w projektach open source, udziela się na blogach oraz czyta książki o kosmosie i astrofizyce.