Merge pull request #36 from bonsai-rx/discriminator-dev

glopesdev · web-flow · commit a11b1a8e1add · 2024-01-24T22:56:06.000Z
Add support for deep oneOf inheritance
diff --git a/Bonsai.Sgen.Tests/DiscriminatorGenerationTests.cs b/Bonsai.Sgen.Tests/DiscriminatorGenerationTests.cs
@@ -1,5 +1,6 @@
 ﻿using Microsoft.VisualStudio.TestTools.UnitTesting;
 using NJsonSchema;
+using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
 
@@ -214,10 +215,49 @@ public void GenerateFromArrayItemDiscriminatorRef_EnsureFallbackDiscriminatorBas
             var code = generator.GenerateFile();
             Assert.IsTrue(code.Contains("class Dog : Animal"), "Derived types do not inherit from base type.");
             Assert.IsTrue(!code.Contains("public enum DogKind"), "Discriminator property is repeated in derived types.");
-            Assert.IsTrue(code.Contains("List<Animal> Animal"), "Container element type does not match base type.");
+            Assert.IsTrue(code.Contains("List<Animal> Animals"), "Container element type does not match base type.");
             Assert.IsTrue(code.Contains("[JsonInheritanceAttribute(\"Dog\", typeof(Dog))]"));
             AssertDiscriminatorAttribute(code, serializerLibraries, "kind");
             CompilerTestHelper.CompileFromSource(code);
         }
+
+        [TestMethod]
+        [DataRow(SerializerLibraries.YamlDotNet)]
+        [DataRow(SerializerLibraries.NewtonsoftJson)]
+        [DataRow(SerializerLibraries.NewtonsoftJson | SerializerLibraries.YamlDotNet)]
+        public void GenerateFromSubDiscriminatorSchemas_InheritanceHierarchyIsPreserved(SerializerLibraries serializerLibraries)
+        {
+            var subTypeSchemas = SchemaTestHelper.CreateDerivedSchemas("fur", "long", "short");
+            var subDiscriminator = SchemaTestHelper.CreateDiscriminatorSchema("fur", subTypeSchemas);
+            var derivedSchemas = SchemaTestHelper.CreateDerivedSchemas("type", "cat", "dog");
+            derivedSchemas[0].Value.DiscriminatorObject = subDiscriminator.DiscriminatorObject;
+            foreach (var subSchema in subDiscriminator.OneOf)
+            {
+                derivedSchemas[0].Value.OneOf.Add(subSchema);
+            }
+            var discriminator = SchemaTestHelper.CreateDiscriminatorSchema("type", derivedSchemas);
+            var schema = SchemaTestHelper.CreateContainerSchema(new Dictionary<string, JsonSchema>
+            {
+                { "LongFurCat", subTypeSchemas[0].Value },
+                { "Cat", derivedSchemas[0].Value },
+                { "Dog", derivedSchemas[1].Value },
+                { "Animal", discriminator },
+                { "ShortFurCat", subTypeSchemas[1].Value }
+            });
+            schema.Properties.Add("Animals", new()
+            {
+                Type = JsonObjectType.Array,
+                Item = new() { Reference = discriminator }
+            });
+
+            var generator = TestHelper.CreateGenerator(schema, serializerLibraries);
+            var code = generator.GenerateFile();
+            Assert.IsTrue(code.Contains("class Cat : Animal"), "Derived types do not inherit from base type.");
+            Assert.IsTrue(!code.Contains("public enum LongFurCatFur"), "Discriminator property is repeated in derived types.");
+            Assert.IsTrue(code.Contains("List<Animal> Animals"), "Container element type does not match base type.");
+            Assert.IsTrue(code.Contains("[JsonInheritanceAttribute(\"dog\", typeof(Dog))]"));
+            AssertDiscriminatorAttribute(code, serializerLibraries, "type");
+            CompilerTestHelper.CompileFromSource(code);
+        }
     }
 }
diff --git a/Bonsai.Sgen.Tests/TestHelper.cs b/Bonsai.Sgen.Tests/TestHelper.cs
@@ -8,7 +8,7 @@ public static CSharpCodeDomGenerator CreateGenerator(
             JsonSchema schema,
             SerializerLibraries serializerLibraries = SerializerLibraries.YamlDotNet | SerializerLibraries.NewtonsoftJson)
         {
-            schema = schema.WithUniqueDiscriminatorProperties();
+            schema = schema.WithResolvedDiscriminatorInheritance();
             var settings = new CSharpCodeDomGeneratorSettings
             {
                 Namespace = nameof(TestHelper),
diff --git a/Bonsai.Sgen/CSharpClassTemplate.cs b/Bonsai.Sgen/CSharpClassTemplate.cs
@@ -4,6 +4,7 @@
 using System.Text;
 using System.Xml.Serialization;
 using Newtonsoft.Json;
+using NJsonSchema;
 using NJsonSchema.Converters;
 using YamlDotNet.Serialization;
 
@@ -30,7 +31,7 @@ public override void BuildType(CodeTypeDeclaration type)
             var jsonSerializer = Settings.SerializerLibraries.HasFlag(SerializerLibraries.NewtonsoftJson);
             var yamlSerializer = Settings.SerializerLibraries.HasFlag(SerializerLibraries.YamlDotNet);
             if (Model.IsAbstract) type.TypeAttributes |= System.Reflection.TypeAttributes.Abstract;
-            if (Model.HasDiscriminator)
+            if (Model.Schema.DiscriminatorObject is OpenApiDiscriminator discriminator)
             {
                 if (jsonSerializer || yamlSerializer)
                 {
@@ -39,13 +40,13 @@ public override void BuildType(CodeTypeDeclaration type)
                         type.CustomAttributes.Add(new CodeAttributeDeclaration(
                             new CodeTypeReference(typeof(JsonConverter)),
                             new CodeAttributeArgument(new CodeTypeOfExpression(nameof(JsonInheritanceConverter))),
-                            new CodeAttributeArgument(new CodePrimitiveExpression(Model.Discriminator))));
+                            new CodeAttributeArgument(new CodePrimitiveExpression(discriminator.PropertyName))));
                     }
                     if (yamlSerializer)
                     {
                         type.CustomAttributes.Add(new CodeAttributeDeclaration(
                             new CodeTypeReference("YamlDiscriminator"),
-                            new CodeAttributeArgument(new CodePrimitiveExpression(Model.Discriminator))));
+                            new CodeAttributeArgument(new CodePrimitiveExpression(discriminator.PropertyName))));
                     }
 
                     foreach (var derivedModel in Model.DerivedClasses)
diff --git a/Bonsai.Sgen/CSharpCodeDomGenerator.cs b/Bonsai.Sgen/CSharpCodeDomGenerator.cs
@@ -105,7 +105,7 @@ public override IEnumerable<CodeArtifact> GenerateTypes()
                               let classType = type as CSharpClassCodeArtifact
                               where classType != null
                               select classType).ToList();
-            var discriminatorTypes = classTypes.Where(modelType => modelType.Model.HasDiscriminator).ToList();
+            var discriminatorTypes = classTypes.Where(modelType => modelType.Model.Schema.DiscriminatorObject != null).ToList();
             foreach (var type in discriminatorTypes)
             {
                 var matchTemplate = new CSharpTypeMatchTemplate(type, _provider, _options, Settings);
diff --git a/Bonsai.Sgen/CSharpTypeResolver.cs b/Bonsai.Sgen/CSharpTypeResolver.cs
@@ -12,11 +12,6 @@ public CSharpTypeResolver(CSharpGeneratorSettings settings)
         {
         }
 
-        public CSharpTypeResolver(CSharpGeneratorSettings settings, JsonSchema exceptionSchema)
-            : base(settings, exceptionSchema)
-        {
-        }
-
         public override JsonSchema RemoveNullability(JsonSchema schema)
         {
             JsonSchema? selectedSchema = null;
diff --git a/Bonsai.Sgen/JsonSchemaExtensions.cs b/Bonsai.Sgen/JsonSchemaExtensions.cs
@@ -1,21 +1,22 @@
 ﻿using NJsonSchema;
-using NJsonSchema.CodeGeneration;
 using NJsonSchema.Visitors;
 
 namespace Bonsai.Sgen
 {
     internal static class JsonSchemaExtensions
     {
-        public static JsonSchema WithUniqueDiscriminatorProperties(this JsonSchema schema)
+        public static JsonSchema WithResolvedDiscriminatorInheritance(this JsonSchema schema)
         {
-            var visitor = new DiscriminatorSchemaVisitor(schema);
-            visitor.Visit(schema);
+            var discriminatorVisitor = new DiscriminatorSchemaVisitor(schema);
+            var derivedDiscriminatorVisitor = new DerivedDiscriminatorSchemaVisitor();
+            discriminatorVisitor.Visit(schema);
+            derivedDiscriminatorVisitor.Visit(schema);
             return schema;
         }
 
         class DiscriminatorSchemaVisitor : JsonSchemaVisitorBase
         {
-            readonly Dictionary<JsonSchema, string> reverseTypeNameLookup = new();
+            readonly Dictionary<JsonSchema, string> definitionTypeNameLookup = new();
 
             public DiscriminatorSchemaVisitor(JsonSchema rootObject)
             {
@@ -34,7 +35,11 @@ private void ResolveOneOfInheritance(JsonSchema schema, JsonSchema baseSchema)
                         continue;
                     }
 
-                    derivedSchema.ActualSchema.AllOf.Add(new JsonSchema { Reference = baseSchema });
+                    var actualSchema = derivedSchema.ActualSchema;
+                    if (!actualSchema.AllOf.Any(schema => schema.Reference == baseSchema))
+                    {
+                        actualSchema.AllOf.Add(new JsonSchema { Reference = baseSchema });
+                    }
                 }
             }
 
@@ -43,15 +48,16 @@ protected override JsonSchema VisitSchema(JsonSchema schema, string path, string
                 var actualSchema = schema.ActualSchema;
                 if (actualSchema.DiscriminatorObject != null)
                 {
-                    if (schema is JsonSchemaProperty || schema.ParentSchema?.Item == schema)
+                    var isDefinition = definitionTypeNameLookup.TryGetValue(actualSchema, out _);
+                    if (schema is JsonSchemaProperty || schema.ParentSchema?.Item == schema || isDefinition)
                     {
-                        if (string.IsNullOrEmpty(typeNameHint) &&
-                            !reverseTypeNameLookup.TryGetValue(actualSchema, out typeNameHint))
+                        var discriminatorSchema = isDefinition ? actualSchema : null;
+                        if (string.IsNullOrEmpty(typeNameHint))
                         {
                             typeNameHint = "Anonymous";
                         }
 
-                        if (!RootObject.Definitions.TryGetValue(typeNameHint, out JsonSchema? discriminatorSchema))
+                        if (discriminatorSchema == null && !RootObject.Definitions.TryGetValue(typeNameHint, out discriminatorSchema))
                         {
                             discriminatorSchema = new JsonSchema();
                             discriminatorSchema.DiscriminatorObject = actualSchema.DiscriminatorObject;
@@ -64,23 +70,13 @@ protected override JsonSchema VisitSchema(JsonSchema schema, string path, string
                             if (discriminatorSchema.OneOf.Count > 0)
                             {
                                 ResolveOneOfInheritance(discriminatorSchema, discriminatorSchema);
-                                discriminatorSchema.OneOf.Clear();
                             }
                         }
 
-                        schema.DiscriminatorObject = null;
-                        schema.IsAbstract = false;
-                        return schema;
-                    }
-
-                    foreach (var derivedSchema in schema.GetDerivedSchemas(RootObject).Keys)
-                    {
-                        foreach (var property in derivedSchema.Properties.Keys.ToList())
+                        if (!isDefinition)
                         {
-                            if (property == schema.Discriminator)
-                            {
-                                derivedSchema.Properties.Remove(property);
-                            }
+                            actualSchema.DiscriminatorObject = null;
+                            actualSchema.IsAbstract = false;
                         }
                     }
                 }
@@ -111,7 +107,7 @@ private void VisitDefinitions(JsonSchema schema)
                 {
                     foreach (var definition in schema.Definitions)
                     {
-                        reverseTypeNameLookup[definition.Value] = definition.Key;
+                        definitionTypeNameLookup[definition.Value] = definition.Key;
                         VisitDefinitions(definition.Value);
                     }
                 }
@@ -139,5 +135,22 @@ private void VisitDefinitions(IDictionary<string, JsonSchemaProperty> dictionary
                 }
             }
         }
+
+        class DerivedDiscriminatorSchemaVisitor : JsonSchemaVisitorBase
+        {
+            protected override JsonSchema VisitSchema(JsonSchema schema, string path, string typeNameHint)
+            {
+                foreach (var baseSchema in schema.AllInheritedSchemas)
+                {
+                    var discriminatorSchema = baseSchema.DiscriminatorObject;
+                    if (discriminatorSchema != null)
+                    {
+                        schema.Properties.Remove(discriminatorSchema.PropertyName);
+                    }
+                }
+
+                return schema;
+            }
+        }
     }
 }
diff --git a/Bonsai.Sgen/Program.cs b/Bonsai.Sgen/Program.cs
@@ -63,7 +63,7 @@ static async Task Main(string[] args)
                     SerializerLibraries = serializerLibraries
                 };
 
-                schema = schema.WithUniqueDiscriminatorProperties();
+                schema = schema.WithResolvedDiscriminatorInheritance();
                 var generator = new CSharpCodeDomGenerator(schema, settings);
                 var code = generator.GenerateFile(generatorTypeName);
                 if (string.IsNullOrEmpty(outputFilePath))

Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,7 @@ public static CSharpCodeDomGenerator CreateGenerator(`
`8`	`8`	`JsonSchema schema,`
`9`	`9`	`SerializerLibraries serializerLibraries = SerializerLibraries.YamlDotNet \| SerializerLibraries.NewtonsoftJson)`
`10`	`10`	`{`
`11`		`- schema = schema.WithUniqueDiscriminatorProperties();`
	`11`	`+ schema = schema.WithResolvedDiscriminatorInheritance();`
`12`	`12`	`var settings = new CSharpCodeDomGeneratorSettings`
`13`	`13`	`{`
`14`	`14`	`Namespace = nameof(TestHelper),`
Original file line number	Diff line number	Diff line change
`@@ -4,6 +4,7 @@`
`4`	`4`	`using System.Text;`
`5`	`5`	`using System.Xml.Serialization;`
`6`	`6`	`using Newtonsoft.Json;`
	`7`	`+using NJsonSchema;`
`7`	`8`	`using NJsonSchema.Converters;`
`8`	`9`	`using YamlDotNet.Serialization;`
`9`	`10`
`@@ -30,7 +31,7 @@ public override void BuildType(CodeTypeDeclaration type)`
`30`	`31`	`var jsonSerializer = Settings.SerializerLibraries.HasFlag(SerializerLibraries.NewtonsoftJson);`
`31`	`32`	`var yamlSerializer = Settings.SerializerLibraries.HasFlag(SerializerLibraries.YamlDotNet);`
`32`	`33`	`if (Model.IsAbstract) type.TypeAttributes \|= System.Reflection.TypeAttributes.Abstract;`
`33`		`- if (Model.HasDiscriminator)`
	`34`	`+ if (Model.Schema.DiscriminatorObject is OpenApiDiscriminator discriminator)`
`34`	`35`	`{`
`35`	`36`	`if (jsonSerializer \|\| yamlSerializer)`
`36`	`37`	`{`
`@@ -39,13 +40,13 @@ public override void BuildType(CodeTypeDeclaration type)`
`39`	`40`	`type.CustomAttributes.Add(new CodeAttributeDeclaration(`
`40`	`41`	`new CodeTypeReference(typeof(JsonConverter)),`
`41`	`42`	`new CodeAttributeArgument(new CodeTypeOfExpression(nameof(JsonInheritanceConverter))),`
`42`		`- new CodeAttributeArgument(new CodePrimitiveExpression(Model.Discriminator))));`
	`43`	`+ new CodeAttributeArgument(new CodePrimitiveExpression(discriminator.PropertyName))));`
`43`	`44`	`}`
`44`	`45`	`if (yamlSerializer)`
`45`	`46`	`{`
`46`	`47`	`type.CustomAttributes.Add(new CodeAttributeDeclaration(`
`47`	`48`	`new CodeTypeReference("YamlDiscriminator"),`
`48`		`- new CodeAttributeArgument(new CodePrimitiveExpression(Model.Discriminator))));`
	`49`	`+ new CodeAttributeArgument(new CodePrimitiveExpression(discriminator.PropertyName))));`
`49`	`50`	`}`
`50`	`51`
`51`	`52`	`foreach (var derivedModel in Model.DerivedClasses)`
Original file line number	Diff line number	Diff line change
`@@ -105,7 +105,7 @@ public override IEnumerable<CodeArtifact> GenerateTypes()`
`105`	`105`	`let classType = type as CSharpClassCodeArtifact`
`106`	`106`	`where classType != null`
`107`	`107`	`select classType).ToList();`
`108`		`- var discriminatorTypes = classTypes.Where(modelType => modelType.Model.HasDiscriminator).ToList();`
	`108`	`+ var discriminatorTypes = classTypes.Where(modelType => modelType.Model.Schema.DiscriminatorObject != null).ToList();`
`109`	`109`	`foreach (var type in discriminatorTypes)`
`110`	`110`	`{`
`111`	`111`	`var matchTemplate = new CSharpTypeMatchTemplate(type, _provider, _options, Settings);`
Original file line number	Diff line number	Diff line change
`@@ -12,11 +12,6 @@ public CSharpTypeResolver(CSharpGeneratorSettings settings)`
`12`	`12`	`{`
`13`	`13`	`}`
`14`	`14`
`15`		`- public CSharpTypeResolver(CSharpGeneratorSettings settings, JsonSchema exceptionSchema)`
`16`		`- : base(settings, exceptionSchema)`
`17`		`- {`
`18`		`- }`
`19`		`-`
`20`	`15`	`public override JsonSchema RemoveNullability(JsonSchema schema)`
`21`	`16`	`{`
`22`	`17`	`JsonSchema? selectedSchema = null;`
Original file line number	Diff line number	Diff line change
`@@ -1,21 +1,22 @@`
`1`	`1`	`using NJsonSchema;`
`2`		`-using NJsonSchema.CodeGeneration;`
`3`	`2`	`using NJsonSchema.Visitors;`
`4`	`3`
`5`	`4`	`namespace Bonsai.Sgen`
`6`	`5`	`{`
`7`	`6`	`internal static class JsonSchemaExtensions`
`8`	`7`	`{`
`9`		`- public static JsonSchema WithUniqueDiscriminatorProperties(this JsonSchema schema)`
	`8`	`+ public static JsonSchema WithResolvedDiscriminatorInheritance(this JsonSchema schema)`
`10`	`9`	`{`
`11`		`- var visitor = new DiscriminatorSchemaVisitor(schema);`
`12`		`- visitor.Visit(schema);`
	`10`	`+ var discriminatorVisitor = new DiscriminatorSchemaVisitor(schema);`
	`11`	`+ var derivedDiscriminatorVisitor = new DerivedDiscriminatorSchemaVisitor();`
	`12`	`+ discriminatorVisitor.Visit(schema);`
	`13`	`+ derivedDiscriminatorVisitor.Visit(schema);`
`13`	`14`	`return schema;`
`14`	`15`	`}`
`15`	`16`
`16`	`17`	`class DiscriminatorSchemaVisitor : JsonSchemaVisitorBase`
`17`	`18`	`{`
`18`		`- readonly Dictionary<JsonSchema, string> reverseTypeNameLookup = new();`
	`19`	`+ readonly Dictionary<JsonSchema, string> definitionTypeNameLookup = new();`
`19`	`20`
`20`	`21`	`public DiscriminatorSchemaVisitor(JsonSchema rootObject)`
`21`	`22`	`{`
`@@ -34,7 +35,11 @@ private void ResolveOneOfInheritance(JsonSchema schema, JsonSchema baseSchema)`
`34`	`35`	`continue;`
`35`	`36`	`}`
`36`	`37`
`37`		`- derivedSchema.ActualSchema.AllOf.Add(new JsonSchema { Reference = baseSchema });`
	`38`	`+ var actualSchema = derivedSchema.ActualSchema;`
	`39`	`+ if (!actualSchema.AllOf.Any(schema => schema.Reference == baseSchema))`
	`40`	`+ {`
	`41`	`+ actualSchema.AllOf.Add(new JsonSchema { Reference = baseSchema });`
	`42`	`+ }`
`38`	`43`	`}`
`39`	`44`	`}`
`40`	`45`
`@@ -43,15 +48,16 @@ protected override JsonSchema VisitSchema(JsonSchema schema, string path, string`
`43`	`48`	`var actualSchema = schema.ActualSchema;`
`44`	`49`	`if (actualSchema.DiscriminatorObject != null)`
`45`	`50`	`{`
`46`		`- if (schema is JsonSchemaProperty \|\| schema.ParentSchema?.Item == schema)`
	`51`	`+ var isDefinition = definitionTypeNameLookup.TryGetValue(actualSchema, out _);`
	`52`	`+ if (schema is JsonSchemaProperty \|\| schema.ParentSchema?.Item == schema \|\| isDefinition)`
`47`	`53`	`{`
`48`		`- if (string.IsNullOrEmpty(typeNameHint) &&`
`49`		`- !reverseTypeNameLookup.TryGetValue(actualSchema, out typeNameHint))`
	`54`	`+ var discriminatorSchema = isDefinition ? actualSchema : null;`
	`55`	`+ if (string.IsNullOrEmpty(typeNameHint))`
`50`	`56`	`{`
`51`	`57`	`typeNameHint = "Anonymous";`
`52`	`58`	`}`
`53`	`59`
`54`		`- if (!RootObject.Definitions.TryGetValue(typeNameHint, out JsonSchema? discriminatorSchema))`
	`60`	`+ if (discriminatorSchema == null && !RootObject.Definitions.TryGetValue(typeNameHint, out discriminatorSchema))`
`55`	`61`	`{`
`56`	`62`	`discriminatorSchema = new JsonSchema();`
`57`	`63`	`discriminatorSchema.DiscriminatorObject = actualSchema.DiscriminatorObject;`
`@@ -64,23 +70,13 @@ protected override JsonSchema VisitSchema(JsonSchema schema, string path, string`
`64`	`70`	`if (discriminatorSchema.OneOf.Count > 0)`
`65`	`71`	`{`
`66`	`72`	`ResolveOneOfInheritance(discriminatorSchema, discriminatorSchema);`
`67`		`- discriminatorSchema.OneOf.Clear();`
`68`	`73`	`}`
`69`	`74`	`}`
`70`	`75`
`71`		`- schema.DiscriminatorObject = null;`
`72`		`- schema.IsAbstract = false;`
`73`		`- return schema;`
`74`		`- }`
`75`		`-`
`76`		`- foreach (var derivedSchema in schema.GetDerivedSchemas(RootObject).Keys)`
`77`		`- {`
`78`		`- foreach (var property in derivedSchema.Properties.Keys.ToList())`
	`76`	`+ if (!isDefinition)`
`79`	`77`	`{`
`80`		`- if (property == schema.Discriminator)`
`81`		`- {`
`82`		`- derivedSchema.Properties.Remove(property);`
`83`		`- }`
	`78`	`+ actualSchema.DiscriminatorObject = null;`
	`79`	`+ actualSchema.IsAbstract = false;`
`84`	`80`	`}`
`85`	`81`	`}`
`86`	`82`	`}`
`@@ -111,7 +107,7 @@ private void VisitDefinitions(JsonSchema schema)`
`111`	`107`	`{`
`112`	`108`	`foreach (var definition in schema.Definitions)`
`113`	`109`	`{`
`114`		`- reverseTypeNameLookup[definition.Value] = definition.Key;`
	`110`	`+ definitionTypeNameLookup[definition.Value] = definition.Key;`
`115`	`111`	`VisitDefinitions(definition.Value);`
`116`	`112`	`}`
`117`	`113`	`}`
`@@ -139,5 +135,22 @@ private void VisitDefinitions(IDictionary<string, JsonSchemaProperty> dictionary`
`139`	`135`	`}`
`140`	`136`	`}`
`141`	`137`	`}`
	`138`	`+`
	`139`	`+ class DerivedDiscriminatorSchemaVisitor : JsonSchemaVisitorBase`
	`140`	`+ {`
	`141`	`+ protected override JsonSchema VisitSchema(JsonSchema schema, string path, string typeNameHint)`
	`142`	`+ {`
	`143`	`+ foreach (var baseSchema in schema.AllInheritedSchemas)`
	`144`	`+ {`
	`145`	`+ var discriminatorSchema = baseSchema.DiscriminatorObject;`
	`146`	`+ if (discriminatorSchema != null)`
	`147`	`+ {`
	`148`	`+ schema.Properties.Remove(discriminatorSchema.PropertyName);`
	`149`	`+ }`
	`150`	`+ }`
	`151`	`+`
	`152`	`+ return schema;`
	`153`	`+ }`
	`154`	`+ }`
`142`	`155`	`}`
`143`	`156`	`}`