Fluent is basically damaged

The extra I take advantage of the Fluent ORM framework the extra I understand how laborious it’s to work with it. I am speaking a few explicit design challenge that I additionally talked about in the way forward for server facet Swift article. I actually do not like the thought of property wrappers and summary database fashions.

What’s the issue with the present database mannequin abstraction? Initially, the non-compulsory ID property is complicated. For instance you do not have to supply an identifier whenever you insert a report, it may be an nil worth and the ORM system can create a novel identifier (beneath the hood utilizing a generator) for you. So why do now we have an id for create operations in any respect? Sure, you would possibly say that it’s potential to specify a customized identifier, however actually what number of occasions do we want that? If you wish to establish a report that is going to be one thing like a key, not an id discipline. 🙃

Additionally this non-compulsory property could cause another points, when utilizing fluent you’ll be able to require an id, which is a throwing operation, alternatively you’ll be able to unwrap the non-compulsory property should you’re positive that the identifier already exists, however this isn’t a protected strategy in any respect.

My different challenge is said to initializers, should you outline a customized mannequin you all the time have to supply an empty init() {} methodology for it, in any other case the compiler will complain, as a result of fashions should be lessons. BUT WHY? IMHO the rationale pertains to this challenge: you’ll be able to question the database fashions utilizing the mannequin itself. So the mannequin acts like a repository that you should use to question the fields, and it additionally represents the the report itself. Is not this towards the clear rules? 🤔

Okay, one very last thing. Property wrappers, discipline keys and migrations. The core members at Vapor instructed us that this strategy will present a protected method to question my fashions and I can ensure that discipline keys will not be tousled, however I am truly battling versioning on this case. I needed to introduce a v1, v2, vN construction each for the sector keys and the migration, which truly feels a bit worse than utilizing uncooked strings. It’s over-complicated for positive, and it feels just like the schema definition is blended up with the precise question mechanism and the mannequin layer as properly.

Sorry of us, I actually recognize the hassle that you have put into Fluent, however these points are actual and I do know which you could repair them on the long run and make the developer expertise quite a bit higher.

make Fluent a bit higher?

On the quick time period I am making an attempt to repair these points and luckily there’s a good strategy to separate the question mechanism from the mannequin layer. It’s known as the repository sample and I might like to offer an enormous credit score to 0xTim once more, as a result of he made a cool reply on StackOverlow about this matter.

Anyway, the principle thought is that you just wrap the Request object right into a customized repository, it is normally a struct, then you definately solely name database associated queries inside this particular object. If we check out on the default mission template (you’ll be able to generate one by utilizing the vapor toolbox), we are able to simply create a brand new repository for the Todo fashions.

import Vapor
import Fluent

struct TodoRepository {
    var req: Request
    
    
    init(req: Request) {
        self.req = req
    }
    
    
    func question() -> QueryBuilder<Todo> {
        Todo.question(on: req.db)
    }
    
    
    func question(_ id: Todo.IDValue) -> QueryBuilder<Todo> {
        question().filter(.$id == id)
    }
    
    
    func question(_ ids: [Todo.IDValue]) -> QueryBuilder<Todo> {
        question().filter(.$id ~~ ids)
    }

    
    func record() async throws -> [Todo] {
        attempt await question().all()
    }
    
    
    func get(_ id: Todo.IDValue) async throws -> Todo? {
        attempt await get([id]).first
    }

    
    func get(_ ids: [Todo.IDValue]) async throws -> [Todo] {
        attempt await question(ids).all()
    }

    
    func create(_ mannequin: Todo) async throws -> Todo {
        attempt await mannequin.create(on: req.db)
        return mannequin
    }
    
    
    func replace(_ mannequin: Todo) async throws -> Todo {
        attempt await mannequin.replace(on: req.db)
        return mannequin
    }

    
    func delete(_ id: Todo.IDValue) async throws {
        attempt await delete([id])
    }

    
    func delete(_ ids: [Todo.IDValue]) async throws {
        attempt await question(ids).delete()
    }
}

That is how we’re can manipulate Todo fashions, any longer you do not have to make use of the static strategies on the mannequin itself, however you should use an occasion of the repository to change your database rows. The repository could be hooked as much as the Request object by utilizing a typical sample. The simplest manner is to return a service each time you want it.

import Vapor

extension Request {
    
    var todo: TodoRepository {
        .init(req: self)
    }
}

In fact it is a very primary answer and it pollutes the namespace beneath the Request object, I imply, if in case you have numerous repositories this is usually a drawback, however first let me present you tips on how to refactor the controller by utilizing this straightforward methodology. 🤓

import Vapor

struct TodoController: RouteCollection {

    func boot(routes: RoutesBuilder) throws {
        let todos = routes.grouped("todos")
        todos.get(use: index)
        todos.submit(use: create)
        todos.group(":todoID") { todo in
            todo.delete(use: delete)
        }
    }

    func index(req: Request) async throws -> [Todo] {
        attempt await req.todo.record()
    }

    func create(req: Request) async throws -> Todo {
        let todo = attempt req.content material.decode(Todo.self)
        return attempt await req.todo.create(todo)
    }

    func delete(req: Request) async throws -> HTTPStatus {
        guard let id = req.parameters.get("todoID", as: Todo.IDValue.self) else {
            throw Abort(.notFound)
        }
        attempt await req.todo.delete(id)
        return .okay
    }
}

As you’ll be able to see this manner we have been in a position to remove the Fluent dependency from the controller, and we are able to merely name the suitable methodology utilizing the repository occasion. Nonetheless if you wish to unit take a look at the controller it isn’t potential to mock the repository, so now we have to determine one thing about that challenge. First we want some new protocols.

public protocol Repository {
    init(_ req: Request)
}

public protocol TodoRepository: Repository {
    func question() -> QueryBuilder<Todo>
    func question(_ id: Todo.IDValue) -> QueryBuilder<Todo>
    func question(_ ids: [Todo.IDValue]) -> QueryBuilder<Todo>
    func record() async throws -> [Todo]
    func get(_ ids: [Todo.IDValue]) async throws -> [Todo]
    func get(_ id: Todo.IDValue) async throws -> Todo?
    func create(_ mannequin: Todo) async throws -> Todo
    func replace(_ mannequin: Todo) async throws -> Todo
    func delete(_ ids: [Todo.IDValue]) async throws
    func delete(_ id: Todo.IDValue) async throws
}

Subsequent we will outline a shared repository registry utilizing the Utility extension. This registry will permit us to register repositories for given identifiers, we’ll use the RepositoryId struct for this objective. The RepositoryRegistry will be capable of return a manufacturing unit occasion with a reference to the required request and registry service, this manner we’re going to have the ability to create an precise Repository primarily based on the identifier. In fact this complete ceremony could be averted, however I wished to give you a generic answer to retailer repositories beneath the req.repository namespace. 😅

public struct RepositoryId: Hashable, Codable {

    public let string: String
    
    public init(_ string: String) {
        self.string = string
    }
}

public closing class RepositoryRegistry {

    personal let app: Utility
    personal var builders: [RepositoryId: ((Request) -> Repository)]

    fileprivate init(_ app: Utility) {
        self.app = app
        self.builders = [:]
    }

    fileprivate func builder(_ req: Request) -> RepositoryFactory {
        .init(req, self)
    }
    
    fileprivate func make(_ id: RepositoryId, _ req: Request) -> Repository {
        guard let builder = builders[id] else {
            fatalError("Repository for id `(id.string)` is just not configured.")
        }
        return builder(req)
    }
    
    public func register(_ id: RepositoryId, _ builder: @escaping (Request) -> Repository) {
        builders[id] = builder
    }
}

public struct RepositoryFactory {
    personal var registry: RepositoryRegistry
    personal var req: Request
    
    fileprivate init(_ req: Request, _ registry: RepositoryRegistry) {
        self.req = req
        self.registry = registry
    }

    public func make(_ id: RepositoryId) -> Repository {
        registry.make(id, req)
    }
}

public extension Utility {

    personal struct Key: StorageKey {
        typealias Worth = RepositoryRegistry
    }
    
    var repositories: RepositoryRegistry {
        if storage[Key.self] == nil {
            storage[Key.self] = .init(self)
        }
        return storage[Key.self]!
    }
}

public extension Request {
    
    var repositories: RepositoryFactory {
        software.repositories.builder(self)
    }
}

As a developer you simply should give you a brand new distinctive identifier and prolong the RepositoryFactory along with your getter in your personal repository sort.

public extension RepositoryId {
    static let todo = RepositoryId("todo")
}

public extension RepositoryFactory {

    var todo: TodoRepository {
        guard let end result = make(.todo) as? TodoRepository else {
            fatalError("Todo repository is just not configured")
        }
        return end result
    }
}

We will now register the FluentTodoRepository object, we simply should rename the unique TodoRepository struct and conform to the protocol as an alternative.

public struct FluentTodoRepository: TodoRepository {
    var req: Request
    
    public init(_ req: Request) {
        self.req = req
    }
    
    func question() -> QueryBuilder<Todo> {
        Todo.question(on: req.db)
    }

    
}


app.repositories.register(.todo) { req in
    FluentTodoRepository(req)
}

We’re going to have the ability to get the repository by way of the req.repositories.todo property. You do not have to vary the rest contained in the controller file.

import Vapor

struct TodoController: RouteCollection {

    func boot(routes: RoutesBuilder) throws {
        let todos = routes.grouped("todos")
        todos.get(use: index)
        todos.submit(use: create)
        todos.group(":todoID") { todo in
            todo.delete(use: delete)
        }
    }

    func index(req: Request) async throws -> [Todo] {
        attempt await req.repositories.todo.record()
    }

    func create(req: Request) async throws -> Todo {
        let todo = attempt req.content material.decode(Todo.self)
        return attempt await req.repositories.todo.create(todo)
    }

    func delete(req: Request) async throws -> HTTPStatus {
        guard let id = req.parameters.get("todoID", as: Todo.IDValue.self) else {
            throw Abort(.notFound)
        }
        attempt await req.repositories.todo.delete(id)
        return .okay
    }
}

One of the best a part of this strategy is which you could merely exchange the FluentTodoRepository with a MockTodoRepository for testing functions. I additionally like the truth that we do not pollute the req.* namespace, however each single repository has its personal variable beneath the repositories key.

You may give you a generic DatabaseRepository protocol with an related database Mannequin sort, then you could possibly implement some primary options as a protocol extension for the Fluent fashions. I am utilizing this strategy and I am fairly pleased with it thus far, what do you assume? Ought to the Vapor core staff add higher help for repositories? Let me know on Twitter. ☺️