How should RelationTraits using on_condition be implemented such that they are reversable?

[roblperry]

I have

impl RelationTrait for SubjectToAccessControl {
    fn def(&self) -> RelationDef {
        fn build_relation_def<T: EntityTrait>(entity: T) -> RelationDef
        where
            access_control::Entity: Related<T>
        {
            T::has_many(access_control::Entity)
                .on_condition(move |_, ac| {
                    Expr::col((ac, access_control::Column::SubjectEntityType))
                        .eq(entity.table_name())
                        .into_condition()
                })
                .into()
        }

        match self {
            Self::Campaign => build_relation_def(campaign::Entity),
            Self::User => build_relation_def(user::Entity),
        }
    }
}

which works fine for:

    #[test]
    fn campaign_access_controlled_by() {
        let actual = campaign::Entity::find()
            .select_only()
            .column(campaign::Column::Id)
            .join(JoinType::InnerJoin, SubjectToAccessControl::Campaign.def())
            .filter(access_control::Column::Id.eq(Uuid::default()))
            .build(DbBackend::Postgres)
            .to_string();

        let expected = r#"
            SELECT 
                "campaign"."id" 
            FROM "campaign" INNER JOIN "access_control" 
                ON "campaign"."id" = "access_control"."subject_entity_id" AND 
                "access_control"."subject_entity_type" = 'campaign'
            WHERE 
                "access_control"."id" = '00000000-0000-0000-0000-000000000000'
        "#;

        let normalized_expected = normalize_whitespace(expected);
        let normalized_actual = normalize_whitespace(&actual);

        assert_eq!(normalized_expected, normalized_actual);
    }

But fails for

    #[test]
    fn rev_campaign_access_controlled_by() {
        let actual = access_control::Entity::find()
            .select_only()
            .column(access_control::Column::Id)
            .join(JoinType::InnerJoin, SubjectToAccessControl::Campaign.def().rev())
            .filter(campaign::Column::Id.eq(Uuid::default()))
            .build(DbBackend::Postgres)
            .to_string();

        let expected = r#"
            SELECT 
                "access_control"."id" 
            FROM "access_control" INNER JOIN "campaign" 
                ON "access_control"."subject_entity_id" = "campaign"."id" AND 
                "access_control"."subject_entity_type" = 'campaign'
            WHERE 
                "campaign"."id" = '00000000-0000-0000-0000-000000000000'
        "#;

        let normalized_expected = normalize_whitespace(expected);
        let normalized_actual = normalize_whitespace(&actual);

        assert_eq!(normalized_expected, normalized_actual);
    }

Because the sql produced is

SELECT 
  "access_control"."id" 
FROM "access_control" INNER JOIN "campaign" 
    ON "access_control"."subject_entity_id" = "campaign"."id" AND
    "campaign"."subject_entity_type" = 'campaign' 
WHERE 
    "campaign"."id" = '00000000-0000-0000-0000-000000000000'

and campaign does not have a 'subject_entity_type', access_control does.

From my perspective the trouble is that rev is implemented as:

pub fn rev(self) -> Self {
        Self {
            rel_type: self.rel_type,
            from_tbl: self.to_tbl,
            to_tbl: self.from_tbl,
            from_col: self.to_col,
            to_col: self.from_col,
            is_owner: !self.is_owner,
            on_delete: self.on_delete,
            on_update: self.on_update,
            on_condition: self.on_condition,
            fk_name: None,
            condition_type: self.condition_type,
        }
    }

Where I would expect it to be something more like:

pub fn rev(self) -> Self {
        Self {
            rel_type: self.rel_type,
            from_tbl: self.to_tbl,
            to_tbl: self.from_tbl,
            from_col: self.to_col,
            to_col: self.from_col,
            is_owner: !self.is_owner,
            on_delete: self.on_delete,
            on_update: self.on_update,
            on_condition: match self.on_condition {
                Some(f) => Some(Box::new( move |a, b| f(b,a))),
                None => None
            },
            fk_name: None,
            condition_type: self.condition_type,
        }
    }

But, a lot of people are using it as is. So, how to we write our on_condition so that a rev does not clobber it?