Services, Storage and Dependency Injection

// Vapor 4.122.2
public protocol StorageKey {
    /// The type of the stored value associated with this key type.
    associatedtype Value: Sendable
}

import Vapor

struct BookshelfSettings: Sendable {
    var libraryName: String
    var maxLoansPerMember: Int
}

extension Application {
    private struct BookshelfSettingsKey: StorageKey {
        typealias Value = BookshelfSettings
    }

    /// Typed, defaulted access to the settings; assign it once in `configure(_:)`.
    var bookshelf: BookshelfSettings {
        get {
            storage[BookshelfSettingsKey.self]
                ?? BookshelfSettings(libraryName: "Bookshelf", maxLoansPerMember: 5)
        }
        set {
            storage[BookshelfSettingsKey.self] = newValue
        }
    }
}

extension Request {
    /// Read-only shortcut for handlers.
    var bookshelf: BookshelfSettings {
        application.bookshelf
    }
}

final class Counter {          // not Sendable: a mutable class
    var value = 0
}

extension Application {
    struct CounterKey: StorageKey {
        typealias Value = Counter
    }
}

error: type 'Application.CounterKey.Value' (aka 'Counter') does not conform to the 'Sendable' protocol
note: class 'Counter' does not conform to the 'Sendable' protocol

error: subscript 'subscript(_:)' requires that 'Missing' conform to 'StorageKey'
error: instance method 'lock(for:)' requires that 'Request' conform to 'LockKey'

import NIOConcurrencyHelpers
import Vapor

final class AuditLog: Sendable {
    private let entries = NIOLockedValueBox<[String]>([])

    func record(_ entry: String) {
        entries.withLockedValue { $0.append(entry) }
    }

    var snapshot: [String] {
        entries.withLockedValue { $0 }
    }

    func flush(to logger: Logger) {
        let pending = entries.withLockedValue { $0 }
        logger.info("Flushing audit log", metadata: ["entries": "\(pending.count)"])
    }
}

extension Application {
    private struct AuditLogKey: StorageKey, LockKey {
        typealias Value = AuditLog
    }

    /// Created on first use. The per-key lock makes "check, create, store" atomic.
    var auditLog: AuditLog {
        locks.lock(for: AuditLogKey.self).withLock {
            if let existing = storage[AuditLogKey.self] {
                return existing
            }
            let created = AuditLog()
            let logger = self.logger
            storage.set(AuditLogKey.self, to: created, onShutdown: { log in
                log.flush(to: logger)
            })
            return created
        }
    }
}

import Vapor

struct Book: Content, Equatable {
    var id: UUID?
    var title: String
    var author: String
}

protocol BookRepository: Sendable {
    func all() async throws -> [Book]
    func find(_ id: UUID) async throws -> Book?
    func create(title: String, author: String) async throws -> Book
}

actor InMemoryBookRepository: BookRepository {
    private var books: [UUID: Book] = [:]

    func all() async throws -> [Book] {
        books.values.sorted { $0.title < $1.title }
    }

    func find(_ id: UUID) async throws -> Book? {
        books[id]
    }

    func create(title: String, author: String) async throws -> Book {
        let book = Book(id: UUID(), title: title, author: author)
        books[book.id!] = book
        return book
    }
}

/// How the application builds a repository for a request.
struct BookRepositoryFactory: Sendable {
    let make: @Sendable (Request) -> any BookRepository
}

extension Application {
    private struct BookRepositoryFactoryKey: StorageKey {
        typealias Value = BookRepositoryFactory
    }

    var bookRepositoryFactory: BookRepositoryFactory? {
        get { storage[BookRepositoryFactoryKey.self] }
        set { storage[BookRepositoryFactoryKey.self] = newValue }
    }
}

extension Request {
    var books: any BookRepository {
        guard let factory = application.bookRepositoryFactory else {
            fatalError("No BookRepository configured. Set app.bookRepositoryFactory in configure(_:).")
        }
        return factory.make(self)
    }
}

import BookshelfStore
import Vapor

func configure(_ app: Application) async throws {
    app.bookshelf = BookshelfSettings(libraryName: "City Library", maxLoansPerMember: 3)

    let repository = InMemoryBookRepository()
    app.bookRepositoryFactory = BookRepositoryFactory { _ in repository }

    app.bookStores.use(.inMemory)

    try routes(app)
}

import BookshelfStore
import Vapor

struct CreateBook: Content {
    var title: String
    var author: String
}

struct BooksController: RouteCollection {
    func boot(routes: any RoutesBuilder) throws {
        let books = routes.grouped("books")
        books.get(use: index)
        books.post(use: create)
    }

    @Sendable func index(req: Request) async throws -> [Book] {
        req.application.auditLog.record("list")
        return try await req.books.all()
    }

    @Sendable func create(req: Request) async throws -> Response {
        let input = try req.content.decode(CreateBook.self)
        let book = try await req.books.create(title: input.title, author: input.author)
        req.application.auditLog.record("create \(book.title)")
        return try await book.encodeResponse(status: .created, for: req)
    }
}

func routes(_ app: Application) throws {
    app.get("library") { req async -> String in
        "\(req.bookshelf.libraryName) (max \(req.bookshelf.maxLoansPerMember) loans)"
    }

    app.get("titles") { req async throws -> [String] in
        try await req.bookStore.titles()
    }

    try app.register(collection: BooksController())
}

public import Vapor

/// The abstraction application code depends on.
public protocol BookStore: Sendable {
    func titles() async throws -> [String]
    func add(title: String) async throws
}

/// A trivial in-memory implementation shipped with the package.
public actor InMemoryBookStore: BookStore {
    private var storedTitles: [String]

    public init(titles: [String] = []) {
        self.storedTitles = titles
    }

    public func titles() async throws -> [String] { storedTitles }

    public func add(title: String) async throws { storedTitles.append(title) }
}

extension Application {
    /// `app.bookStores`: the entry point of the package, mirroring `app.caches` and `app.sessions`.
    public var bookStores: BookStores { .init(application: self) }

    public struct BookStores: Sendable {
        /// A named way of configuring the package: `app.bookStores.use(.inMemory)`.
        public struct Provider: Sendable {
            let run: @Sendable (Application) -> Void

            public init(_ run: @escaping @Sendable (Application) -> Void) {
                self.run = run
            }
        }

        private struct Registration: Sendable {
            let store: any BookStore
        }

        private struct Key: StorageKey {
            typealias Value = Registration
        }

        let application: Application

        public func use(_ provider: Provider) {
            provider.run(application)
        }

        public func use(_ store: any BookStore) {
            application.storage[Key.self] = Registration(store: store)
        }

        public var store: any BookStore {
            guard let registration = application.storage[Key.self] else {
                fatalError("No BookStore configured. Configure one with app.bookStores.use(...) in configure(_:).")
            }
            return registration.store
        }
    }
}

extension Application.BookStores.Provider {
    public static var inMemory: Self {
        .init { app in
            app.bookStores.use(InMemoryBookStore())
        }
    }
}

extension Request {
    /// `req.bookStore`: what handlers use.
    public var bookStore: any BookStore {
        application.bookStores.store
    }
}