Filtering with ~~ on enum collection does not work about fluent-kit HOT 6 CLOSED

consumersQuery
	.join(parent: \.$id.$user)
	.filter(DbUser.self, \.$sex ~~ sexes)

struct CreateSexEnum : AsyncMigration {
	
	static let enumName = "sex"
	
	func prepare(on database: Database) async throws {
		assert(Self.enumName.utf8CString.count <= Self.maxAllowedTableNameLength)
		_ = try await database.enum(Self.enumName)
			.case(Sex.male.rawValue)
			.case(Sex.female.rawValue)
			.create()
	}
	
	func revert(on database: Database) async throws {
		try await database.enum(Self.enumName).delete()
	}
	
}

final class DbUser : Model {
	
	static let schema = "users"
	
	@ID
	var id: UUID?
	
	@Timestamp(key: FieldKeys.createdAt, on: .create)
	var createdAt: Date?
	
	@Timestamp(key: FieldKeys.updatedAt, on: .update)
	var updatedAt: Date?
	
	@Field(key: FieldKeys.firstName)
	var firstName: String
	
	@OptionalEnum(key: FieldKeys.sex)
	var sex: Sex?
	
	@OptionalChild(for: \.$id.$user)
	var i_consumerProfile: DbConsumerProfile?
	
	/* *******
	   MARK: -
	   ******* */
	
	enum FieldKeys {
		
		static let createdAt: FieldKey = "created_at"
		static let updatedAt: FieldKey = "updated_at"
		
		static let firstName: FieldKey = "first_name"
		static let sex: FieldKey = "sex"
		
	}
	
}

struct CreateUsersTable : AsyncMigration {
	
	typealias Table = DbUser
	typealias Keys = Table.FieldKeys
	
	func prepare(on database: Database) async throws {
		assert(Table.schema.utf8CString.count <= Self.maxAllowedTableNameLength)
		let sexEnum = try await database.enum(CreateSexEnum.enumName).read()
		try await database.schema(Table.schema)
			.id()
			.field(Keys.createdAt,          .datetime, .required)
			.field(Keys.updatedAt,          .datetime, .required)
			.field(Keys.firstName,          .string,   .required)
->			.field(Keys.sex,                 sexEnum)
			…
			.unique(on: .id)
			.create()
	}
	
	func revert(on database: Database) async throws {
		try await database.schema(Table.schema).delete()
	}
	
}

final class DbConsumerProfile : Model {
	
	static let schema = "consumer_profiles"
	
	final class IDValue : Fields, Hashable {
		
		@Parent(key: FieldKeys.userID)
		var user: DbUser
		
		init() {}
		
		init(_ userID: UUID) {
			self.$user.id = userID
		}
		
		init(user: DbUser) throws {
			self.$user.id = try user.requireID()
			self.$user.value = user
		}
		
		func duplicate() -> Self {
			return .init($user.id)
		}
		
		public static func ==(lhs: IDValue, rhs: IDValue) -> Bool {
			lhs.$user.id == rhs.$user.id
		}
		
		public func hash(into hasher: inout Hasher) {
			hasher.combine($user.id)
		}
		
	}
	
	@CompositeID()
	var id: IDValue?
	var user: DbUser? {id?.user}
	func requireUserID() throws -> UUID {
		return try requireID().$user.id
	}
	func setUser(_ dbUser: DbUser) throws {
		id = try .init(user: dbUser)
	}
	
	@Timestamp(key: FieldKeys.createdAt, on: .create)
	var createdAt: Date?
	
	@Timestamp(key: FieldKeys.updatedAt, on: .update)
	var updatedAt: Date?
	
	enum FieldKeys {
		
		static let userID: FieldKey = "user_id"
		
		static let createdAt: FieldKey = DbUser.FieldKeys.createdAt
		static let updatedAt: FieldKey = DbUser.FieldKeys.updatedAt
		
	}
	
}

struct CreateConsumerProfilesTable : AsyncMigration {
	
	typealias Table = DbConsumerProfile
	typealias Keys = Table.FieldKeys
	
	func prepare(on database: Database) async throws {
		assert(Table.schema.utf8CString.count <= Self.maxAllowedTableNameLength)
		try await database.schema(Table.schema)
			.field(Keys.userID,                          .uuid,     .required, .references(DbUser.schema,    FieldKey.id, onDelete: .cascade), .identifier(auto: false))
			.field(Keys.createdAt,                       .datetime, .required)
			.field(Keys.updatedAt,                       .datetime, .required)
			.unique(on: Keys.userID)
			.create()
	}
	
	func revert(on database: Database) async throws {
		try await database.schema(Table.schema).delete()
	}
	
}