NullReferenceException in shaper for tuple query when a query-filtered entity is reached via both a scalar and collection navigation #3933

using Microsoft.EntityFrameworkCore;
using Npgsql;
using Testcontainers.MsSql;
using Testcontainers.PostgreSql;

var sqlServerContainer = new MsSqlBuilder().Build();
var postgresContainer = new PostgreSqlBuilder().Build();

await sqlServerContainer.StartAsync();
await postgresContainer.StartAsync();

await Run("sqlserver", new SqlServerReproContext(sqlServerContainer.GetConnectionString()));
await Run("postgres", new PostgresReproContext(postgresContainer.GetConnectionString()));

await sqlServerContainer.DisposeAsync();
await postgresContainer.DisposeAsync();

static async Task Run(string label, ReproContext context)
{
    await using (context)
    {
        await context.Database.EnsureCreatedAsync();

        const short OrgId = 1;
        var orderIdentifier = Guid.NewGuid();

        var representative = new Representative { Id = 1, OrgId = OrgId, IsActive = true };
        var vendor = new Vendor { Id = 1, OrgId = OrgId, IsActive = true, Representatives = [representative] };
        var vendorLink = new VendorLink { Id = 1, OrgId = OrgId, Vendor = vendor };
        var order = new Order { Id = 1, OrgId = OrgId, OrderIdentifier = orderIdentifier, VendorLinks = [vendorLink] };

        context.Orders.Add(order);
        await context.SaveChangesAsync();

        Console.WriteLine($"--- {label} ---");

        try
        {
            var result = await context.Orders
                .Where(x => x.OrderIdentifier == orderIdentifier)
                .Select(x => ValueTuple.Create(
                    x.Id,
                    x.VendorLinks.Any(vl => vl.Vendor.IsActive && vl.Vendor.Representatives.Any(r => r.IsActive))))
                .FirstOrDefaultAsync();

            Console.WriteLine($"SUCCESS: ({result.Item1}, {result.Item2})");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"FAILED: {ex.GetType().Name}: {ex.Message}");
            Console.WriteLine(ex.StackTrace);
        }

        Console.WriteLine();
    }
}

public class Representative
{
    public int Id { get; set; }
    public short OrgId { get; set; }
    public Guid RepresentativeIdentifier { get; set; }
    public int VendorId { get; set; }
    public bool IsActive { get; set; }
}

public class Vendor
{
    public int Id { get; set; }
    public short OrgId { get; set; }
    public Guid VendorIdentifier { get; set; }
    public bool IsActive { get; set; }
    public List<Representative> Representatives { get; set; } = [];
}

public class VendorLink
{
    public int Id { get; set; }
    public short OrgId { get; set; }
    public Guid VendorLinkIdentifier { get; set; }
    public int OrderId { get; set; }
    public int? VendorId { get; set; }
    public Vendor? Vendor { get; set; }
}

public class Order
{
    public int Id { get; set; }
    public short OrgId { get; set; }
    public Guid OrderIdentifier { get; set; }
    public List<VendorLink> VendorLinks { get; set; } = [];
}

public abstract class ReproContext : DbContext
{
    public short OrgId { get; set; } = 1;

    public DbSet<Order> Orders => Set<Order>();

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Representative>().HasKey(e => new { e.OrgId, e.Id });

        modelBuilder.Entity<Vendor>(builder =>
        {
            builder.HasKey(e => new { e.OrgId, e.Id });
            builder
                .HasMany(v => v.Representatives)
                .WithOne()
                .HasForeignKey(r => new { r.OrgId, r.VendorId })
                .IsRequired();

            modelBuilder.Entity<Vendor>().HasQueryFilter(x => x.OrgId == OrgId);
        });

        modelBuilder.Entity<VendorLink>(builder =>
        {
            builder.HasKey(e => new { e.OrgId, e.Id });
            builder
                .HasOne(vl => vl.Vendor)
                .WithMany()
                .HasForeignKey(vl => new { vl.OrgId, vl.VendorId })
                .IsRequired(false);
        });

        modelBuilder.Entity<Order>(builder =>
        {
            builder.HasKey(e => new { e.OrgId, e.Id });
            builder
                .HasMany(o => o.VendorLinks)
                .WithOne()
                .HasForeignKey(vl => new { vl.OrgId, vl.OrderId })
                .IsRequired();
        });
    }
}

public sealed class SqlServerReproContext(string connectionString) : ReproContext
{
    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        => optionsBuilder.UseSqlServer(connectionString);
}

public sealed class PostgresReproContext(string connectionString) : ReproContext
{
    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        var dataSourceBuilder = new NpgsqlDataSourceBuilder(connectionString);
        dataSourceBuilder.EnableRecordsAsTuples();
        optionsBuilder.UseNpgsql(dataSourceBuilder.Build());
    }
}