Small fixes

Author: papafe

src/MongoDB.Bson/BsonExtensionMethods.cs

@@ -26,7 +26,7 @@ namespace MongoDB.Bson
     public static class BsonExtensionMethods
     {
         //DOMAIN-API We should remove this and use the version with the domain.
-        //QUESTION: Do we want to do something now about this...? It's used also internally, but in a huge number of places.
+        //QUESTION: Do we want to do something now about this...? It's used also internally, but it seems in most cases it's used for "default serialization", so it should be ok.
         /// <summary>
         /// Serializes an object to a BSON byte array.
         /// </summary>

src/MongoDB.Driver/MongoDatabase.cs

@@ -613,12 +613,11 @@ private IWriteOperation<BsonDocument> CreateCreateCollectionOperation<TDocument>
             var documentSerializer = options.DocumentSerializer ?? serializerRegistry.GetSerializer<TDocument>();
 
             //DOMAIN-API This will need to go away
+            //This is only happening in a couple of places, it's not worth to find better solutions right now.
             RenderArgs<TDocument> renderArgs = options.SerializationDomain is null ?
                 new(documentSerializer, serializerRegistry, translationOptions: translationOptions) :
                 new(documentSerializer, options.SerializationDomain, translationOptions: translationOptions);
 
-            //var serializationDomain = Settings.SerializationDomain.WithSerializerRegistry(serializerRegistry);  //FP This could be the way to go
-
             //DOMAIN-API This will need to go away
             var clusteredIndex = options.SerializationDomain is null?
                 options.ClusteredIndex?.Render(documentSerializer, serializerRegistry, translationOptions):

src/MongoDB.Driver/PipelineStageDefinitionBuilder.cs

@@ -544,6 +544,7 @@ public static PipelineStageDefinition<TInput, TOutput> Facet<TInput, TOutput>(
 
             const string operatorName = "$facet";
             var materializedFacets = facets.ToArray();
+
             var stage = new DelegatedPipelineStageDefinition<TInput, TOutput>(
                 operatorName,
                 args =>
@@ -556,7 +557,25 @@ public static PipelineStageDefinition<TInput, TOutput> Facet<TInput, TOutput>(
                         facetsDocument.Add(facet.Name, renderedPipeline);
                     }
                     var document = new BsonDocument("$facet", facetsDocument);
-                    var outputSerializer = options?.OutputSerializer ?? args.SerializerRegistry.GetSerializer<TOutput>();
+
+                    IBsonSerializer<TOutput> outputSerializer;
+
+                    if (options?.OutputSerializer is not null)
+                    {
+                        outputSerializer = options.OutputSerializer;
+                    }
+                    else if (typeof(TOutput) == typeof(AggregateFacetResults))
+                    {
+                        outputSerializer = (IBsonSerializer<TOutput>)new AggregateFacetResultsSerializer(
+                            materializedFacets.Select(f => f.Name),
+                            materializedFacets.Select(f => f.OutputSerializer ?? args.SerializerRegistry.GetSerializer(f.OutputType)));  //QUESTION What do we do? Do we delay the setting of the serializer..?
+                    }
+                    else
+                    {
+                        outputSerializer = args.SerializerRegistry.GetSerializer<TOutput>();
+                    }
+
+                    //var outputSerializer = options?.OutputSerializer ?? args.SerializerRegistry.GetSerializer<TOutput>();
                     return new RenderedPipelineStageDefinition<TOutput>(operatorName, document, outputSerializer);
                 });
 
@@ -572,12 +591,7 @@ public static PipelineStageDefinition<TInput, TOutput> Facet<TInput, TOutput>(
         public static PipelineStageDefinition<TInput, AggregateFacetResults> Facet<TInput>(
             IEnumerable<AggregateFacet<TInput>> facets)
         {
-            Ensure.IsNotNull(facets, nameof(facets));
-            var outputSerializer = new AggregateFacetResultsSerializer(
-                facets.Select(f => f.Name),
-                facets.Select(f => f.OutputSerializer ?? BsonSerializer.SerializerRegistry.GetSerializer(f.OutputType)));  //QUESTION What do we do? Do we delay the setting of the serializer..?
-            var options = new AggregateFacetOptions<AggregateFacetResults> { OutputSerializer = outputSerializer };
-            return Facet(facets, options);
+            return Facet<TInput, AggregateFacetResults>(facets, options: null);
         }
 
         /// <summary>

tests/MongoDB.Driver.Tests/MultipleRegistriesTests.cs

@@ -173,12 +173,14 @@ public void TestDiscriminators()
             {
                 cm.AutoMap();
                 cm.SetDiscriminator("dp1");
+                cm.MapMember( m => m.ExtraField1).SetSerializer(new CustomStringSerializer());
             });
 
             customDomain.BsonClassMap.RegisterClassMap<DerivedPerson2>(cm =>
             {
                 cm.AutoMap();
                 cm.SetDiscriminator("dp2");
+                cm.MapMember( m => m.ExtraField2).SetSerializer(new CustomStringSerializer());
             });
 
             var client = CreateClientWithDomain(customDomain);
@@ -192,31 +194,67 @@ public void TestDiscriminators()
             var retrievedDerivedPerson1 = collection.Aggregate().OfType<DerivedPerson1>().Single();
             var retrievedDerivedPerson2 = collection.Aggregate().OfType<DerivedPerson2>().Single();
 
-            Assert.Equal(bp1.Id, retrievedDerivedPerson1.Id);
-            Assert.Equal(bp2.Id, retrievedDerivedPerson2.Id);
+            AssertDerivedPerson1(bp1, retrievedDerivedPerson1);
+            AssertDerivedPerson2(bp2, retrievedDerivedPerson2);
 
             //AppendStage with OfType
             retrievedDerivedPerson1 = collection.AsQueryable().AppendStage(PipelineStageDefinitionBuilder.OfType<BasePerson, DerivedPerson1>())
                 .OfType<DerivedPerson1>().Single();
             retrievedDerivedPerson2 = collection.AsQueryable().AppendStage(PipelineStageDefinitionBuilder.OfType<BasePerson, DerivedPerson2>())
                 .OfType<DerivedPerson2>().Single();
 
-            Assert.Equal(bp1.Id, retrievedDerivedPerson1.Id);
-            Assert.Equal(bp2.Id, retrievedDerivedPerson2.Id);
+            AssertDerivedPerson1(bp1, retrievedDerivedPerson1);
+            AssertDerivedPerson2(bp2, retrievedDerivedPerson2);
 
             //LINQ with OfType
             retrievedDerivedPerson1 = collection.AsQueryable().OfType<DerivedPerson1>().Single();
             retrievedDerivedPerson2 = collection.AsQueryable().OfType<DerivedPerson2>().Single();
 
-            Assert.Equal(bp1.Id, retrievedDerivedPerson1.Id);
-            Assert.Equal(bp2.Id, retrievedDerivedPerson2.Id);
+            AssertDerivedPerson1(bp1, retrievedDerivedPerson1);
+            AssertDerivedPerson2(bp2, retrievedDerivedPerson2);
+
+            //Facet with OfType
+
+            var pipeline1 = PipelineDefinition<BasePerson, DerivedPerson1>.Create( new [] {
+                PipelineStageDefinitionBuilder.OfType<BasePerson, DerivedPerson1>() });
+            var facet1 = AggregateFacet.Create("facet1", pipeline1);
+
+            var pipeline2 = PipelineDefinition<BasePerson, DerivedPerson2>.Create( new [] {
+                PipelineStageDefinitionBuilder.OfType<BasePerson, DerivedPerson2>() });
+            var facet2 = AggregateFacet.Create("facet2", pipeline2);
+
+            var result = collection.Aggregate().Facet(facet1, facet2).Single().Facets;
+            retrievedDerivedPerson1 = result[0].Output<DerivedPerson1>().Single();
+            retrievedDerivedPerson2 = result[1].Output<DerivedPerson2>().Single();
+
+            AssertDerivedPerson1(bp1, retrievedDerivedPerson1);
+            AssertDerivedPerson2(bp2, retrievedDerivedPerson2);
 
             //Find with OfType
             var retrievedBasePerson1 = collection.FindSync(Builders<BasePerson>.Filter.OfType<DerivedPerson1>()).Single();
             var retrievedBasePerson2 = collection.FindSync(Builders<BasePerson>.Filter.OfType<DerivedPerson2>()).Single();
 
-            Assert.Equal(bp1.Id, retrievedBasePerson1.Id);
-            Assert.Equal(bp2.Id, retrievedBasePerson2.Id);
+            AssertBasePerson(bp1, retrievedBasePerson1);
+            AssertBasePerson(bp2, retrievedBasePerson2);
+
+            void AssertDerivedPerson1(DerivedPerson1 expected, DerivedPerson1 retrieved)
+            {
+                AssertBasePerson(expected, retrieved);
+                Assert.Equal(expected.ExtraField1, retrieved.ExtraField1);
+            }
+
+            void AssertDerivedPerson2(DerivedPerson2 expected, DerivedPerson2 retrieved)
+            {
+                AssertBasePerson(expected, retrieved);
+                Assert.Equal(expected.ExtraField2, retrieved.ExtraField2);
+            }
+
+            void AssertBasePerson(BasePerson expected, BasePerson retrieved)
+            {
+                Assert.Equal(expected.Id, retrieved.Id);
+                Assert.Equal(expected.Name, retrieved.Name);
+                Assert.Equal(expected.Age, retrieved.Age);
+            }
         }
 
         private static IMongoCollection<T> GetTypedCollection<T>(IMongoClient client) =>