Would you consider changing the API to:

try router.crud(register: User.self) { controller in
    try controller.crud(children: \.todos)
}

?

`final class Account: SQLiteModel {
var id: Int?

var username: String
var password: String
var avatar: String?

}`

Steps:

1. I want to create a new account.
2. Add router.crud(register: Account.self) in router.swift
3. It always add successfully.
4. But, username not check. I hope it is a unique property.
5. How to check it ?

I'm getting the following run-time error:

RoutingKit/TrieRouter.swift:215: Precondition failed: It is not possible to have two routes with the same prefix but different parameter names, even if the trailing path components differ (tried to add route with clubID that collides with eventID).

I'm probably doing something stupid here. I've a parent (Club), children (Event) and grandchildren (Table) - to represent a bridge club. Here's the model:

import Fluent
import Vapor

final class Club: Model, Content {
    static let schema = "club"
    
    @ID(key: .id)
    var id: UUID?
    
    @Field(key: "name")
    var name: String
    
    @Children(for: \.$club)
    var events: [Event]
    
    init() { }
    
    init(
        id: UUID? = nil,
        name: String
    ) {
        self.id = id
        self.name = name
    }
}

final class Event: Model, Content {
    static let schema = "event"
    
    @ID(key: .id)
    var id: UUID?
    
    @Parent(key: "club_id")
    var club: Club
    
    @Field(key: "date")
    var date: Date
    
    @Children(for: \.$event)
    var tables: [Table]
    
    init() { }
    
    init(
        id: UUID? = nil,
        clubID: Club.IDValue,
        date: Date
    ) {
        self.id = id
        self.$club.id = clubID
        
        self.date = date
    }
}

final class Table: Model, Content {
    static let schema = "table"
    
    @ID(key: .id)
    var id: UUID?
    
    @Parent(key: "event_id")
    var event: Event
    
    init() { }
    
    init(
        id: UUID? = nil,
        eventID: Event.IDValue
    ) {
        self.id = id
        self.$event.id = eventID
    }
}

Heres my routes.swift:

import Fluent
import Vapor
import CrudRouter

func routes(_ app: Application) throws {
    app.crud(register: Club.self) { router in
        router.crud(children: \.$events) { router in
            router.crud(children: \.$tables)
        }
    }
    
    for route in app.routes.all {
        print(route.description)
    }
}

I'm expecting the print out of the app.routes.all to generate something like:

PUT /club/:clubID
DELETE /club/:clubID
POST /club
GET /club
GET /club/:clubID
GET /club/:clubID/event
POST /club/:clubID/event
GET /club/:clubID/event/:eventID
DELETE /club/:clubID/event/:eventID
PUT /club/:clubID/event/:eventID
POST /club/:clubID/event/:eventID/table
DELETE /club/:clubID/event/:eventID/table/:tableID
GET /club/:clubID/event/:eventID/table/:tableID
GET /club/:clubID/event/:eventID/table
PUT /club/:clubID/event/:eventID/table/:tableID

But its actually generating:

PUT /club/:clubID
DELETE /club/:clubID
POST /club
GET /club
GET /club/:clubID
GET /club/:clubID/event
POST /club/:clubID/event
GET /club/:clubID/event/:eventID
DELETE /club/:clubID/event/:eventID
PUT /club/:clubID/event/:eventID
POST /club/:clubID/event/:clubID/table
DELETE /club/:clubID/event/:clubID/table/:tableID
GET /club/:clubID/event/:clubID/table/:tableID
GET /club/:clubID/event/:clubID/table
PUT /club/:clubID/event/:clubID/table/:tableID

Where the last five routes use the clubID for the event resource.

Hi there. I stumbled across this project while trying to learn some Vapor :-) I did some rails a long time ago and was trying to figure out how to make the vapor router behave the way I wanted and your project seemed like just the thing.

However....

I have two models, Project and Issue.

Project contains

    var issues: Children<Project, Issue> {
        return children(\.projectId)
    }

Issue contains

    var project: Parent<Issue, Project> {
          return parent(\.projectId)
    }

My routing file contains

    router.crud(register: Project.self) { controller in
        controller.crud(children: \.issues)
    }

But the generates routes appear to be

+--------+----------------------------+
| POST   | /project/:int/project      |
+--------+----------------------------+
| GET    | /project/:int/project/:int |
+--------+----------------------------+
| GET    | /project/:int/project      |
+--------+----------------------------+
| DELETE | /project/:int/project/:int |
+--------+----------------------------+
| PUT    | /project/:int/project/:int |
+--------+----------------------------+

And I can't figure out what I'm doing wrong. Any help appreciated :-)

It seems to be best practice not to decode a model directly but decoding a ModelCreate struct (or similar) instead. Although it is great to add crud functionality directly to a Model, what about adding (optional) protocols like below, so if someone wants to specify the requests (and also a public response)

protocol Createable {
    associatedtype Create: Content
    init(from data: Create) throws
}

Could be used like this:

extension User: Createable {
    struct Create: Content {
        var name: String
        var email: String
        var password: String
    }
    
    convenience init(from data: Create) throws {
        let password = try Bcrypt.hash(data.password)
        self.init(id: nil, name: data.name, email: data.email, password: password)
    }
}

Although this would add a lot of extra code for using CRUDRouter, this would make the package much more customizable. Also Patch requests could be implemented easily then, providing a custom struct with optional fields. And what about validation support?