组合根

//entity
class Order {
    constructor(
        readonly id: number,
        readonly total: number) {
    }

    payable(): number {
        return this.total >= 200
            ? this.total - Math.trunc(this.total / 10)
            : this.total
    }
}

//gateway
interface ICatalog {
    price(sku: string): number | undefined
}

//repository
interface IOrders {
    save(order: Order): void
    count(): number
}

//output port
interface IReport {
    say(text: string): void
}

//use case: asks for its parts, never builds them
class PlaceOrder {
    private nextId = 1001

    constructor(
        private catalog: ICatalog,
        private orders: IOrders,
        private report: IReport) {
    }

    place(items: Map<string, number>) {
        let total = 0
        for (let [sku, count] of items) {
            let price = this.catalog.price(sku)
            if (price === undefined) {
                this.report.say("no " + sku)
                return
            }
            total += price * count
        }
        let order = new Order(this.nextId++, total)
        this.orders.save(order)
        this.report.say("order " + order.id +
            " for " + order.payable())
    }
}

//adapters
class MemoryCatalog implements ICatalog {
    private prices = new Map([["pen", 30], ["lamp", 190]])

    price(sku: string): number | undefined {
        return this.prices.get(sku)
    }
}

class MemoryOrders implements IOrders {
    private rows: Order[] = []

    save(order: Order) {
        this.rows.push(order)
    }

    count(): number {
        return this.rows.length
    }
}

class ConsoleReport implements IReport {
    say(text: string) {
        console.log(text)
    }
}

class SilentReport implements IReport {
    say(text: string) {
    }
}

//the parts of a built application
type ShopApp = {
    readonly useCase: PlaceOrder
    readonly orders: IOrders
}

//composition root: the only place that sees every layer
//at once, and the only place where new stands next to
//an adapter. no container is needed, a function is it
function build(report: IReport): ShopApp {
    let orders = new MemoryOrders()
    return {
        useCase: new PlaceOrder(
            new MemoryCatalog(), orders, report),
        orders: orders}
}

function loud(): ShopApp {
    return build(new ConsoleReport())
}

function quiet(): ShopApp {
    return build(new SilentReport())
}

//client code
let app = loud()
app.useCase.place(new Map([["pen", 2], ["lamp", 1]]))
app.useCase.place(new Map([["chair", 1]]))

//a second root builds the same use case differently
let night = quiet()
night.useCase.place(new Map([["lamp", 1]]))
console.log("night saved " + night.orders.count())
console.log("loud saved " + app.orders.count())
//printed: order 1001 for 225
//         no chair
//         night saved 1
//         loud saved 1