Корень композиции

//entity
struct Order {
    let id: Int
    let total: Int

    var payable: Int {
        total >= 200 ? total - total / 10 : total
    }
}

//gateway
protocol Catalog {
    func price(_ sku: String) -> Int?
}

//repository
protocol Orders {
    func save(_ order: Order)
    var count: Int { get }
}

//output port
protocol Report {
    func say(_ text: String)
}

//use case: asks for its parts, never builds them
final class PlaceOrder {
    private let catalog: any Catalog
    private let orders: any Orders
    private let report: any Report
    private var nextId = 1001

    init(catalog: any Catalog, orders: any Orders,
         report: any Report) {
        self.catalog = catalog
        self.orders = orders
        self.report = report
    }

    func place(_ items: [(sku: String, count: Int)]) {
        var total = 0
        for item in items {
            guard let price = catalog.price(item.sku) else {
                report.say("no \(item.sku)")
                return
            }
            total += price * item.count
        }
        let order = Order(id: nextId, total: total)
        nextId += 1
        orders.save(order)
        report.say("order \(order.id)"
                   + " for \(order.payable)")
    }
}

//adapter
struct MemoryCatalog: Catalog {
    private let prices = ["pen": 30, "lamp": 190]

    func price(_ sku: String) -> Int? {
        prices[sku]
    }
}

//adapter
final class MemoryOrders: Orders {
    private var rows: [Order] = []

    func save(_ order: Order) {
        rows.append(order)
    }

    var count: Int { rows.count }
}

//adapter
struct ConsoleReport: Report {
    func say(_ text: String) {
        print(text)
    }
}

//adapter
struct SilentReport: Report {
    func say(_ text: String) {
    }
}

//composition root: the only place that sees every layer
//at once, and the only place where an adapter is built
//the default values in the init are the whole container
//this shop needs: a caller names only what it wants to
//be different, and a default is built anew every call
struct ShopApp {
    let useCase: PlaceOrder
    let orders: any Orders

    init(catalog: any Catalog = MemoryCatalog(),
         orders: any Orders = MemoryOrders(),
         report: any Report = ConsoleReport()) {
        self.orders = orders
        self.useCase = PlaceOrder(catalog: catalog,
                                  orders: orders,
                                  report: report)
    }

    static func loud() -> ShopApp {
        ShopApp()
    }

    static func quiet() -> ShopApp {
        ShopApp(report: SilentReport())
    }
}

//client code
let app = ShopApp.loud()
app.useCase.place([(sku: "pen", count: 2),
                   (sku: "lamp", count: 1)])
app.useCase.place([(sku: "chair", count: 1)])

//a second root builds the same use case differently
let night = ShopApp.quiet()
night.useCase.place([(sku: "lamp", count: 1)])
print("saved \(night.orders.count)")
//printed: order 1001 for 225
//         no chair
//         saved 1