Column 'aggregate' sum of 1:M entity column

[christiangroleau]

I'd like to better understand how to create the following scenario:

I have a parent entity column as a sum of values of a 1:M entity's column.

For example, I have 'Account' and 1:M 'Transactions' entity. The Account's 'Balance' column would be the sum of Transactions 'Values' column.

Currently, I am using Mikro ORM's Propagation to achieve this. Whenever I create a new Transaction, I update the Transaction's associated Account's balance then persist the Transaction.

My question: Is there a cleaner way of doing this?

Thank you!

I have provided a snippet of the code I am using.

async create(userId: string, createTransactionInput: CreateTransactionInput): Promise<TransactionEntity> {
        const user = await this.usersRepository.findOneOrFail({ id: userId });
        const account = await this.accountssRepository.findOneOrFail({ id: createTransactionInput.accountId });
        
        // propagation
        account.balance += createTransactionInput.value;
        
        const transaction = this.transactionsRepository.create({
            user: user,
            account: account,
            description: createTransactionInput.description,
            value: createTransactionInput.value,
            transactionType: createTransactionInput.transactionType,
            date: createTransactionInput.date
        });

        try {
            await this.transactionsRepository.persistAndFlush(transaction);
            return transaction;
        } catch (UniqueConstraintViolationException) {
            throw new ConflictException('Transaction with that name, amount and date already exists');
        }
    }

My entities:

@Unique({ properties: ["number", "user", "bank"] })
export class AccountEntity {
  @PrimaryKey()
  id: string = v4();

  // ...

  @Property()
  balance: number = 0;

  @OneToMany(() => TransactionEntity, transaction => transaction.account)
  transactions?: TransactionEntity[];
}

@Entity({ tableName: "transactions" })
export class TransactionEntity {
    @PrimaryKey()
    id: string = v4();

    //...

    @Property()
    value: number;

    @ManyToOne(() => AccountEntity)
    account: AccountEntity;
}```