Make Services in Vapor Usable

[0xTim]

This adds real support to Vapor to make it easy to integrate different services that can be tested.

For example, if you have a service defined as:

protocol MyService {
    func `for`(_ request: Request) -> MyService
    func doSomething() -> String
}

You may then have a real implementation:

import Vapor

struct MyRealService: MyService {
    let logger: Logger
    let eventLoop: EventLoop
    
    func `for`(_ request: Vapor.Request) -> MyService {
        return MyRealService(logger: request.logger, eventLoop: request.eventLoop)
    }
    
    func doSomething() -> String {
        return "Tada"
    }
    
}

This is a very contrived example, but shows a service that needs a Logger and EventLoop - things that are normally tied to specific requests. Doing this in a safe and testable way involves a lot of boilerplate. This moves the boilerplate into Vapor to make it easier to do.

Now, you can define your services:

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)
    }
}

Configure it in configure.swift:

app.services.myService.use { app in
    MyRealService(logger: app.logger, eventLoop: app.eventLoopGroup.next())
}

And then use it in routes:

app.get("myService") { req -> String in
    let thing = req.services.myService.doSomething()
    return thing
}

Testing

This approach makes it very easy to write test services as well. With the protocol defined above, you can create an implementation for testing:

struct MyFakeService: MyService {
    let cannedResponse: String
    let eventLoop: EventLoop
    let logger: Logger
    
    func `for`(_ request: Vapor.Request) -> App.MyService {
        return MyFakeService(cannedResponse: self.cannedResponse, eventLoop: request.eventLoop, logger: request.logger)
    }
    
    func doSomething() -> String {
        return cannedResponse
    }   
}

And then you can configure your test application and use it:

let myFakeServicce = MyFakeService(cannedResponse: testString, eventLoop: app.eventLoopGroup.next(), logger: app.logger)        
app.services.myService.use { _ in
    myFakeServicce
}
    
try app.test(.GET, "myService", afterResponse: { res in
    XCTAssertEqual(res.status, .ok)
    XCTAssertEqual(res.body.string, testString)
})
``

[0xTim]

One point for comment is it might be worth defaulting to making service access async to avoid immediately deprecating everything when #2873 lands

[0xTim]

To add some further context, the original code (the generic Service stuff) was taken from a Vapor 4 project that's been running in production for over 2 years with no issues

[Joannis]

Nit, but there's a lot of whitespace changes.

[Joannis]

Shouldn't we mark these @Sendable from now on?

[Joannis]

@Sendable?

[Joannis]

I know this works fine, but can we make initialize() return the newly created entity? Then return that here.

[Joannis]

public struct instead of public extension? I tend to be explicit in marking things public in libraries/frameworks, so future changes don't accidentally expose internal API.

[Joannis]

Great addition btw!

[DanielSincere]

@0xTim @Joannis @Andrewangeta What's the best way I can help get this merged?

1. I'm using this code in a project
2. Tim has copy-pasted this into Discord at least three times

[Joannis]

What's the goal of this PR?

[0xTim]

@Joannis what do you mean?

[Joannis]

@0xTim sorry for missing your message;
I mean, what's the intention behind this new feature? To make it easier to work with app.storage? Or is there another goal?