Сущность

//entity
class OrderLine {
    constructor(
        readonly sku: string,
        readonly price: number,
        readonly count: number) {
        if (count <= 0) {
            throw new Error("bad count " + sku)
        }
    }

    cost(): number {
        return this.price * this.count
    }
}

//entity
class Order {
    private lines: OrderLine[] = []
    private isPaid = false

    constructor(readonly id: number) {
    }

    add(sku: string, price: number, count: number) {
        this.lines.push(new OrderLine(sku, price, count))
    }

    //the goods leave as a copy: readonly is a word for
    //the compiler and guards nothing while running
    goods(): ReadonlyArray<OrderLine> {
        return this.lines.slice()
    }

    size(): number {
        return this.lines.length
    }

    total(): number {
        let sum = 0
        for (let line of this.lines) {
            sum += line.cost()
        }
        return sum
    }

    //business rule: 10% off from 200
    discount(): number {
        let total = this.total()
        return total >= 200 ? Math.trunc(total / 10) : 0
    }

    payable(): number {
        return this.total() - this.discount()
    }

    //business rule: an empty order is never paid
    pay() {
        if (this.lines.length === 0) {
            throw new Error("empty order")
        }
        this.isPaid = true
    }

    paid(): boolean {
        return this.isPaid
    }
}

//client code
//no database and no screen anywhere above
let order = new Order(1001)
order.add("pen", 30, 2)
order.add("lamp", 190, 1)
console.log("order " + order.id)
console.log("lines " + order.size())
console.log("total " + order.total())
console.log("discount " + order.discount())
console.log("payable " + order.payable())
order.pay()
console.log("paid " + order.paid())

//the same rule on a smaller order
let small = new Order(1002)
small.add("pen", 30, 2)
console.log("small total " + small.total())
console.log("small discount " + small.discount())

//a cast drops readonly, but the copy keeps the order
//whole: the rule lives inside, not in the type
let taken = order.goods() as OrderLine[]
taken.pop()
console.log("still " + order.size())

try {
    new Order(1003).pay()
} catch (error) {
    console.log("refused: " + (error as Error).message)
}

try {
    order.add("pen", 30, 0)
} catch (error) {
    console.log("refused: " + (error as Error).message)
}
//printed: order 1001
//         lines 2
//         total 250
//         discount 25
//         payable 225
//         paid true
//         small total 60
//         small discount 0
//         still 2
//         refused: empty order
//         refused: bad count pen