flattens any future into void

[rafiki270]

using this in my app to transform any future to void easily and was wondering if you think it could be useful elsewhere ... obviously would add tests if so

Also, in my app I have the extension constrained to Content so it doesn't show on Future<Void> which would be pointless but not sure how to do this in pure async ...

[twof]

Also, in my app I have the extension constrained to Content so it doesn't show on Future which would be pointless but not sure how to do this in pure async

Perhaps the extension would be better added to Vapor or Fluent in that case?

Mind sharing a code snippet where you're using the extension?

[rafiki270]

@twof my version of this is:

extension Future where T: Content {
    
    public func flatten() -> Future<Void> {
        return map(to: Void.self, { (_) -> Void in
            return Void()
        })
    }
    
}

and using it in:

    static func handleTags(db: DbCoreConnection, request req: Request, app: App) -> Future<Void> {
        if let query = try? req.query.decode([String: String].self) {
            if let tags = query["tags"]?.split(separator: "|") {
                var futures: [Future<Void>] = []
                // TODO: Optimise to work without the for loop
                for tagSubstring in tags {
                    let tag = String(tagSubstring)
                    let future = Tag.query(on: db).filter(\Tag.identifier == tag).first().flatMap(to: Void.self, { (tagObject) -> Future<Void> in
                        guard let tagObject = tagObject else {
                            let t = Tag(id: nil, name: tag, identifier: tag.safeText)
                            return t.save(on: db).flatMap(to: Void.self, { (tag) -> Future<Void> in
                                return app.tags.attach(tag, on: db).flatten() // Extension used here
                            })
                        }
                        return app.tags.attach(tagObject, on: db).flatten() // and here
                    })
                    futures.append(future)
                }
                return futures.flatten() // Current async method
            }
        }
        return Future<Void>.make()
    }

also in stuff like:

return try app.delete(on: db).flatten().asResponse(to: req)

where the delete I think was still returning the deleted object? (not 100% sure) and I got a helper method that returns a response with 204 status code on empty void futures