DDD 저장소

오늘 나는 2022년 5월 5일을 배웠다

Repositório

Cenário

Implementação

레포지토리

O Vaughn Vernon em seu livro Implementing Domain-Driven Design
repositórios como 정의:

Um repositório comumente se refere a um local de armazenamento, geralmente considerado um local de segurança ou preservação dos itens nele armazenados. Quando você armazena algo em um repositório e depois retorna para recuperá-lo, você espera que ele esteja no mesmo estado que estava quando você o colocou lá. Em algum momento, você pode optar por remover o item armazenado no repositório
VERNON, Vaughn. Implementing Domain-Driven Design

Esses objetos são semelhantes a coleções sobre persistência. Todo tipo de Agregado persistente terá um Repositório. De um modo geral, existe uma relação um-para-um entre um tipo de Agregado e um Repositório
VERNON, Vaughn. Implementing Domain-Driven Design

Ou seja, para cada agregado temos apenas um repositório então se por exemplo voltarmos no exemplo de agregados que eu dei no artigo sobre



Para esse aggregado de customer somente será criado um único repositório, que vai conter os campos de customer E os campos de endereço, não é necessário uma tabela para Address justamente por que o domínio da aplicação é diferente da infraestrutura

Não tem problema a gente implementar o banco de dados pensando em domínio, o problema é implementar o domínio pensando no banco de dados

세나리오

Imaginando uma entidade de order onde cada order precisa ter os seus items associados, sendo que nessa entidade precisamos salvar também o id do usuário que fez o pedido eo produto que é associado ao ordem item.

Porem final das contas o nosso aggregado vai ser esse daqui:

구현

Para fazermos o repositório do nosso agregado de order vamos precisar inicialmente de dois models, o model de OrderItem e o de Order. Vamos criar duas tabelas por banco de dados, lembrando que 1 repositorio compatiblee 1 agregado, porem 1 repositorio não tem essa relação de 1 para 1 com tabela no banco de dados

(추신: o 모델 foi feito utilizando는 기공 o ORM utilizado não importa muito, isso pode ser implementado com qualquer um 후유증):
order-items.model.ts

@Table({
  tableName: 'orders_items',
  timestamps: false
})
export class OrderItemModel extends Model{
  @PrimaryKey
  @Column
  declare id: string;

  @ForeignKey(() => ProductModel)
  @Column({allowNull: false})
  declare product_id: string;

  @BelongsTo(() => ProductModel)
  declare product: ProductModel;

  @ForeignKey(() => OrderModel)
  @Column({allowNull: false})
  declare order_id: string;

  @BelongsTo(() => OrderModel)
  declare order: OrderModel;

  @Column({allowNull: false})
  declare quantity: number;

  @Column({allowNull: false})
  declare name: string;

  @Column({allowNull: false})
  declare price: number;

}

order.model.ts

@Table({
  tableName: 'orders',
  timestamps: false
})
export class OrderModel extends Model{
  @PrimaryKey
  @Column
  declare id: string;

  @ForeignKey(() => CustomerModel)
  @Column({allowNull: false})
  declare customer_id: string;

  @BelongsTo(() => CustomerModel)
  declare customer: CustomerModel;

  @HasMany(() => OrderItemModel)
  declare items: OrderItemModel[]

  @Column({allowNull: false})
  declare total: number;
}

com os 모델 declarados podemos criar o 저장소:

export class OrderRepository{
  async create(entity: Order): Promise<void> {
    await OrderModel.create({
      id: entity.id,
      customer_id: entity.customer_id,
      total: entity.total(),
      items: entity.items.map(item => ({
        id: item.id,
        name: item.name,
        price: item.price,
        quantity: item.quantity,
        product_id: item.productId,
      }))
    },
    {
      include: [{model: OrderItemModel}]
    })
  }

}

따라서 Orders의 정확한 저장소는 주문 항목의 항목 목록에서 항목을 저장하는 uma nova 주문 항목을 quando criarmos에서 encarrega로 저장합니다.

Ainda estou aprendendo sobre DDD e se quiser ver melhor o código pode dar uma olhada nesse Repositório