Filtering Included Relationships not working with IQuery "where" method

The documentation mentions the following:

Filtering Included Relationships
Similarly, you may filter included relationships using where(), and(), and or().

this._userRepository
    .include(u => u.posts)
    .where(p => p.archived)

This doesn’t seem to work with “where”, the inferred type is User, but it works with and/or and post is inferred.

I have been using “and” as a workaround in most cases and it works fine. Not knowing the internals of the code (or tested in depth) the concerns I have are:

• could it be causing other undesirable side effects or is it just the typings?
• a little bit of readability of the query is lost, which I think would be valuable since there is already some level of implicit nesting in the library.
• In case it’s hard to fix, it would be cool if the docs point out the limitation

[IRCraziestTaxi]

I updated the documentation (version 1.0.0-alpha.15) and am going to go ahead and close this issue. I will try to figure something out if somebody opens it back up.

[IRCraziestTaxi]

Ah… I see what’s going on. The Query class allows for it, but the interface does not.

My intention (some time after the time at which the initial documentation was written) was for include to not behave like a join when using where.

My thought was this:

userRepository
    .getMany()
    // I want to include posts in my results.
    .include(u => u.posts)
    // However, I am filtering on the user itself.
    .where(u => u.active)
    .isTrue();

userRepository
    .getMany()
    // Filter results by users who have archived posts.
    // Hence "join where posts are archived".
    .join(u => u.posts)
    .where(p => p.archived)
    .isTrue()
    // Now that "join where" is over, "where" operates on the user again.
    .where(u => u.active)
    .isTrue();

I think the reason I did that was because “include where” didn’t make a lot of sense to me in the sense that doing it the same way as “join where” would yield unexpected results - i.e. “include where” would not give you all users with filtered posts as you might expect, but rather would filter your user results like a “join where” would.

Obviously, given the way it works now, the documentation is extremely misleading and I will update it. I also wonder if “include where” should be allowed, but rather than doing an inner join as “include where” does, it would do a left join to produce the expected results discussed above.

The problem that presents, however, is that would break the way include().where() works now, so it would probably be best to not change the behavior, but rather just update the documentation.

I guess the workaround that will be explained in the updated documentation is to use .include() followed by .join().where() afterwards:

userRepository
    .getMany()
    // Include posts in results.
    .include(u => u.posts)
    // Use .join rather than .joinAlso to actually filter user results by post criteria.
    .join(u => u.posts)
    .where(p => p.archived)
    .isTrue();

userRepository
    .getMany()
    // Include posts in results.
    .include(u => u.posts)
    // Use .joinAlso rather than .join to perform a left join to filter posts but not filter users.
    .joinAlso(u => u.posts)
    .where(p => p.archived)
    .isTrue();

Hopefully, if and when I finally get around to making this work, these weird quirks will be made obsolete as more context can be deduced when parsing the where function.

As a side note, I am surprised that using and without a where before it did not error or produce unexpected results. I may need to check into that as well.