Make Services in Vapor Usable

Sources/Vapor/Services/App+Service.swift

@@ -0,0 +1,9 @@
+extension Application {
+    public struct Services {
+        public let application: Application
+    }
+
+    public var services: Services {
+        .init(application: self)
+    }
+}

Sources/Vapor/Services/Req+Service.swift

@@ -0,0 +1,12 @@
+extension Request {
+    public struct Services {
+        public let request: Request
+        init(request: Request) {
+            self.request = request
+        }
+    }
+
+    public var services: Services {
+        Services(request: self)
+    }
+}

Sources/Vapor/Services/Service.swift

@@ -0,0 +1,53 @@
+public extension Application {
+    struct Service<ServiceType> {
+
+        let application: Application
+
+        public init(application: Application) {
+            self.application = application
+        }
+
+        public struct Provider {
+            let run: (Application) -> ()
+
+            public init(_ run: @escaping (Application) -> ()) {
+                self.run = run
+            }
+        }
+
+        final class Storage {
+            var makeService: ((Application) -> ServiceType)?
+            init() { }
+        }
+
+        struct Key: StorageKey {
+            typealias Value = Storage
+        }
+
+        public var service: ServiceType {
+            guard let makeService = self.storage.makeService else {
+                fatalError("No service configured for \(ServiceType.self)")
+            }
+            return makeService(self.application)
+        }
+
+        public func use(_ provider: Provider) {
+            provider.run(self.application)
+        }
+
+        public func use(_ makeService: @escaping (Application) -> ServiceType) {
+            self.storage.makeService = makeService
+        }
+
+        func initialize() {
+            self.application.storage[Key.self] = .init()
+        }
+
+        private var storage: Storage {
+            if self.application.storage[Key.self] == nil {
+                self.initialize()
+            }
+            return self.application.storage[Key.self]!
+        }
+    }
+}

Tests/VaporTests/ServiceTests.swift

@@ -4,55 +4,108 @@ final class ServiceTests: XCTestCase {
     func testReadOnly() throws {
         let app = Application(.testing)
         defer { app.shutdown() }
-
+        
         app.get("test") { req in
             req.readOnly.foos()
         }
-
+        
         try app.test(.GET, "test") { res in
             XCTAssertEqual(res.status, .ok)
             try XCTAssertEqual(res.content.decode([String].self), ["foo"])
         }
     }
-
+    
     func testWritable() throws {
         let app = Application(.testing)
         defer { app.shutdown() }
-
+        
         app.writable = .init(apiKey: "foo")
         XCTAssertEqual(app.writable?.apiKey, "foo")
     }
-
+    
     func testLifecycle() throws {
         let app = Application(.testing)
         defer { app.shutdown() }
-
+        
         app.lifecycle.use(Hello())
         app.environment.arguments = ["serve"]
         try app.start()
         app.running?.stop()
     }
-
+    
     func testLocks() throws {
         let app = Application(.testing)
         defer { app.shutdown() }
-
+        
         app.sync.withLock {
             // Do something.
         }
-
+        
         struct TestKey: LockKey { }
-
+        
         let test = app.locks.lock(for: TestKey.self)
         test.withLock {
             // Do something.
         }
     }
+
+    func testServiceHelpers() throws {
+        let app = Application(.testing)
+        defer { app.shutdown() }
+
+        let testString = "This is a test - \(Int.random())"
+        let myFakeServicce = MyTestService(cannedResponse: testString, eventLoop: app.eventLoopGroup.next(), logger: app.logger)
+
+        app.services.myService.use { _ in
+            myFakeServicce
+        }
+
+        app.get("myService") { req -> String in
+            let thing = req.services.myService.doSomething()
+            return thing
+        }
+
+        try app.test(.GET, "myService", afterResponse: { res in
+            XCTAssertEqual(res.status, .ok)
+            XCTAssertEqual(res.body.string, testString)
+        })
+    }
+}
+
+protocol MyService {
+    func `for`(_ request: Request) -> MyService
+    func doSomething() -> String
+}
+
+extension Application.Services {
+    var myService: Application.Service<MyService> {
+        .init(application: self.application)
+    }
+}
+
+extension Request.Services {
+    var myService: MyService {
+        self.request.application.services.myService.service.for(request)
+    }
+}
+
+struct MyTestService: MyService {
+    let cannedResponse: String
+    let eventLoop: EventLoop
+    let logger: Logger
+
+    func `for`(_ request: Vapor.Request) -> MyService {
+        return MyTestService(cannedResponse: self.cannedResponse, eventLoop: request.eventLoop, logger: request.logger)
+    }
+
+    func doSomething() -> String {
+        return cannedResponse
+    }
 }
 
 private struct ReadOnly {
     let client: Client
-
+    
     func foos() -> EventLoopFuture<[String]> {
         self.client.eventLoop.makeSucceededFuture(["foo"])
     }