Vapor 3中使用Fluent实现多对多关联的问题求助

我刚巧在Vapor 3里处理过类似的多对多关联问题，你的问题核心是Vapor 3对Pivot的实现做了彻底改动——它不再是Vapor 2里的泛型类，而是变成了一个协议，所以不能直接用Pivot<Community, User>这种写法。下面是完整的解决方案：

Vapor 3要求多对多关联必须有一个明确的中间模型来实现Pivot协议，我们先创建CommunityUserPivot来作为用户和社区的关联表：

import Vapor
import FluentMySQL

// 不需要额外字段的情况，直接继承MySQLPivot（它已经实现了基础Pivot协议）
final class CommunityUserPivot: MySQLPivot {
    // 指定关联的两个模型类型
    typealias Left = Community
    typealias Right = User
    
    // 可选：自定义数据库表名，默认会自动生成类似`community_user`的名称
    static var entity: String? = "community_members"
    
    // 中间表的主键
    var id: Int?
    
    // 关联两个模型的外键字段
    var communityID: Community.ID
    var userID: User.ID
    
    // 初始化方法，用于快速创建关联记录
    init(_ community: Community, _ user: User) throws {
        self.communityID = try community.requireID()
        self.userID = try user.requireID()
    }
}

// 让Pivot支持数据库迁移（自动创建表结构）
extension CommunityUserPivot: Migration { }

// 可选但推荐：添加外键约束，同时支持反向查询
extension CommunityUserPivot: ModifiablePivot {
    static func prepare(on connection: MySQLConnection) -> Future<Void> {
        return MySQLDatabase.create(self, on: connection) { builder in
            try addProperties(to: builder)
            // 添加外键约束，保证数据一致性
            builder.reference(from: \.communityID, to: \Community.id)
            builder.reference(from: \.userID, to: \User.id)
        }
    }
}

现在我们可以用自定义的Pivot模型来定义两个模型间的siblings关联：

final class Community: MySQLModel {
    var id: Int?
    // 补充你的Community属性，比如社区名称
    var name: String
    
    init(id: Int? = nil, name: String) {
        self.id = id
        self.name = name
    }
}

final class User: MySQLModel {
    var id: Int?
    // 补充你的User属性，比如用户名
    var username: String
    
    init(id: Int? = nil, username: String) {
        self.id = id
        self.username = username
    }
}

extension Community {
    // 定义与User的多对多关联，使用我们的自定义Pivot
    var members: Siblings<Community, User, CommunityUserPivot> {
        return siblings()
    }
}

extension User {
    // 反向关联，从User查询所属的Community
    var communities: Siblings<User, Community, CommunityUserPivot> {
        return siblings()
    }
}

别忘了把新的Pivot模型添加到数据库配置中，否则无法创建表和使用关联：

import Vapor
import FluentMySQL

public func configure(_ config: inout Config, _ env: inout Environment, _ services: inout Services) throws {
    // 注册FluentMySQL提供者
    try services.register(FluentMySQLProvider())
    
    // 配置MySQL数据库连接信息
    let mysqlConfig = MySQLDatabaseConfig(
        hostname: "localhost",
        port: 3306,
        username: "root",
        password: "your_password",
        database: "your_database_name"
    )
    services.register(mysqlConfig)
    
    // 注册模型迁移
    services.register { container -> MigrationConfig in
        var migrationConfig = MigrationConfig()
        migrationConfig.add(model: Community.self, database: .mysql)
        migrationConfig.add(model: User.self, database: .mysql)
        migrationConfig.add(model: CommunityUserPivot.self, database: .mysql)
        return migrationConfig
    }
    
    // 其他配置（路由、中间件等）...
}

如果你的中间表需要额外字段（比如用户加入社区的时间joinedAt），就要让Pivot直接遵循ModifiablePivot协议，而不是继承MySQLPivot，示例如下：

final class CommunityUserPivot: ModifiablePivot, MySQLModel {
    var id: Int?
    var communityID: Community.ID
    var userID: User.ID
    var joinedAt: Date // 新增的额外字段
    
    init(_ community: Community, _ user: User, joinedAt: Date = Date()) throws {
        self.communityID = try community.requireID()
        self.userID = try user.requireID()
        self.joinedAt = joinedAt
    }
    
    // 必须实现的两个方法，指定外键字段的路径
    static func leftIDKey() -> WritableKeyPath<CommunityUserPivot, Community.ID> {
        return \.communityID
    }
    
    static func rightIDKey() -> WritableKeyPath<CommunityUserPivot, User.ID> {
        return \.userID
    }
}

// 自定义迁移逻辑，确保额外字段被正确创建
extension CommunityUserPivot: Migration {
    static func prepare(on connection: MySQLConnection) -> Future<Void> {
        return MySQLDatabase.create(self, on: connection) { builder in
            try addProperties(to: builder)
            builder.reference(from: \.communityID, to: \Community.id)
            builder.reference(from: \.userID, to: \User.id)
        }
    }
}

配置完成后，你就可以正常使用多对多关联的操作了，比如给社区添加成员：

// 示例路由：添加用户到指定社区
func addUserToCommunity(_ req: Request) throws -> Future<HTTPStatus> {
    let communityID = try req.parameters.next(Int.self)
    let userID = try req.parameters.next(Int.self)
    
    return Community.find(communityID, on: req)
        .unwrap(or: Abort(.notFound))
        .flatMap { community in
            User.find(userID, on: req)
                .unwrap(or: Abort(.notFound))
                .flatMap { user in
                    community.members.attach(user, on: req)
                }
        }
        .transform(to: .ok)
}

内容的提问来源于stack exchange，提问作者larsschwegmann