Add SchemaGenerator API (#108)

* tweaks to reflection services code:

- rename ServicesExtensions due to collision; combine two static classes
- update Reflection.cs with latest bits
- use the TypeModel that is configured on the binder, not necessarily the default
- fixup intellisense
- yak some IDE warnings

* add SchemaGenerator API

* fix bad merge

Author: mgravell

src/protobuf-net.Grpc.Reflection/FileDescriptorSetFactory.cs

@@ -86,7 +86,7 @@ private static string GetType(BinderConfiguration binderConfiguration, Type type
             var fileName = type.FullName + ".proto";
             var fileDescriptor = fileDescriptorSet.Files.SingleOrDefault(f => f.Name.Equals(fileName, StringComparison.Ordinal));
 
-            TypeModel model = binderConfiguration.TryGetFactory(type) is ProtoBufMarshallerFactory factory ? factory.Model : RuntimeTypeModel.Default;
+            TypeModel model = binderConfiguration.MarshallerCache.TryGetFactory(type) is ProtoBufMarshallerFactory factory ? factory.Model : RuntimeTypeModel.Default;
 
             if (fileDescriptor is null)
             {

src/protobuf-net.Grpc.Reflection/SchemaGenerator.cs

@@ -0,0 +1,110 @@
+using Grpc.Core;
+using ProtoBuf.Grpc.Configuration;
+using ProtoBuf.Grpc.Internal;
+using ProtoBuf.Meta;
+using System;
+using System.Reflection;
+
+namespace ProtoBuf.Grpc.Reflection
+{
+    /// <summary>
+    /// Allows creation of .proto schemas from service contracts
+    /// </summary>
+    public sealed class SchemaGenerator
+    {
+        /// <summary>
+        /// Gets or sets the syntax version
+        /// </summary>
+        public ProtoSyntax ProtoSyntax { get; set; } = ProtoSyntax.Proto3;
+
+        /// <summary>
+        /// Gets or sets the binder configuration (the default configuration is used if omitted)
+        /// </summary>
+        public BinderConfiguration? BinderConfiguration { get; set; }
+
+        /// <summary>
+        /// Get the .proto schema associated with a service contract
+        /// </summary>
+        /// <remarks>This API is considered experimental and may change slightly</remarks>
+        public string GetSchema<TService>()
+            => GetSchema(typeof(TService));
+
+        /// <summary>
+        /// Get the .proto schema associated with a service contract
+        /// </summary>
+        /// <remarks>This API is considered experimental and may change slightly</remarks>
+        public string GetSchema(Type contractType)
+        {
+            var binderConfiguration = BinderConfiguration ?? BinderConfiguration.Default;
+            var binder = binderConfiguration.Binder;
+            if (!binder.IsServiceContract(contractType, out var name))
+            {
+                throw new ArgumentException($"Type '{contractType.Name}' is not a service contract", nameof(contractType));
+            }
+
+            string package = "";
+            var idx = name!.LastIndexOf('.');
+            if (idx >= 0)
+            {
+                package = name.Substring(0, idx);
+                name = name.Substring(idx + 1);
+            }
+            var service = new Service
+            {
+                Name = name
+            };
+            var ops = contractType.GetMethods(BindingFlags.Public | BindingFlags.Instance);
+            foreach (var method in ops)
+            {
+                if (method.DeclaringType == typeof(object))
+                { /* skip */ }
+                else if (ContractOperation.TryIdentifySignature(method, binderConfiguration, out var op, null))
+                {
+                    service.Methods.Add(
+                        new ServiceMethod
+                        {
+                            Name = op.Name,
+                            InputType = ApplySubstitutes(op.From),
+                            OutputType = ApplySubstitutes(op.To),
+                            ClientStreaming = op.MethodType switch
+                            {
+                                MethodType.ClientStreaming => true,
+                                MethodType.DuplexStreaming => true,
+                                _ => false,
+                            },
+                            ServerStreaming = op.MethodType switch
+                            {
+                                MethodType.ServerStreaming => true,
+                                MethodType.DuplexStreaming => true,
+                                _ => false,
+                            },
+                        }
+                    );
+                }
+            }
+            service.Methods.Sort((x, y) => string.Compare(x.Name, y.Name)); // make it predictable
+            var options = new SchemaGenerationOptions
+            {
+                Syntax = ProtoSyntax,
+                Package = package,
+                Services =
+                {
+                    service
+                }
+            };
+
+            var model = binderConfiguration.MarshallerCache.TryGetFactory<ProtoBufMarshallerFactory>()?.Model ?? RuntimeTypeModel.Default;
+            return model.GetSchema(options);
+
+            static Type ApplySubstitutes(Type type)
+            {
+#pragma warning disable CS0618 // Type or member is obsolete
+                if (type == typeof(Empty)) return typeof(WellKnownTypes.Empty);
+#pragma warning restore CS0618 // Type or member is obsolete
+                if (type == typeof(DateTime)) return typeof(WellKnownTypes.Timestamp);
+                if (type == typeof(TimeSpan)) return typeof(WellKnownTypes.Duration);
+                return type;
+            }
+        }
+    }
+}

src/protobuf-net.Grpc.Reflection/protobuf-net.Grpc.Reflection.csproj

@@ -7,9 +7,10 @@
     </PropertyGroup>
 
     <ItemGroup>
-        <PackageReference Include="protobuf-net.Reflection" Version="3.0.17" />
-        <PackageReference Include="protobuf-net" Version="3.0.17" />
-        <PackageReference Include="protobuf-net.Core" Version="3.0.17" />
+        <!-- note this uses v3 features that are not back-ported to v2 -->
+        <PackageReference Include="protobuf-net.Reflection" Version="3.0.21" />
+        <PackageReference Include="protobuf-net" Version="3.0.21" />
+        <PackageReference Include="protobuf-net.Core" Version="3.0.21" />
     </ItemGroup>
 
     <ItemGroup>

src/protobuf-net.Grpc/Configuration/ServiceBinder.cs

@@ -80,7 +80,7 @@ public virtual bool IsServiceContract(Type contractType, out string? name)
                 return true;
             }
 
-            string? serviceName = null;
+            string? serviceName;
             var attribs = AttributeHelper.For(contractType, inherit: true);
             if (attribs.IsDefined("ProtoBuf.Grpc.Configuration.ServiceAttribute"))
             {

src/protobuf-net.Grpc/Internal/MarshallerCache.cs

@@ -77,5 +77,16 @@ internal void SetMarshaller<T>(Marshaller<T>? marshaller)
             }
             return null;
         }
+
+        internal TFactory? TryGetFactory<TFactory>()
+            where TFactory : MarshallerFactory
+        {
+            foreach (var factory in _factories)
+            {
+                if (factory is TFactory typed)
+                    return typed;
+            }
+            return null;
+        }
     }
 }

tests/protobuf-net.Grpc.Reflection.Test/SchemaGeneration.cs

@@ -0,0 +1,101 @@
+using ProtoBuf;
+using ProtoBuf.Grpc;
+using ProtoBuf.Grpc.Reflection;
+using System;
+using System.Collections.Generic;
+using System.Runtime.Serialization;
+using System.ServiceModel;
+using System.Threading.Tasks;
+using Xunit;
+using Xunit.Abstractions;
+
+[module: CompatibilityLevel(CompatibilityLevel.Level300)] // configures how DateTime etc are handled
+
+namespace protobuf_net.Grpc.Reflection.Test
+{
+    public class SchemaGeneration
+    {
+        public SchemaGeneration(ITestOutputHelper log) => _log = log;
+        private readonly ITestOutputHelper _log;
+        private void Log(string message) => _log?.WriteLine(message);
+        [Fact]
+        public void CheckBasicSchema()
+        {
+            var generator = new SchemaGenerator();
+            var schema = generator.GetSchema<IMyService>();
+            Log(schema);
+            Assert.Equal(@"syntax = ""proto3"";
+package protobuf_net.Grpc.Reflection.Test;
+import ""google/protobuf/timestamp.proto"";
+import ""google/protobuf/empty.proto"";
+
+enum Category {
+   Default = 0;
+   Foo = 1;
+   Bar = 2;
+}
+message MyRequest {
+   int32 Id = 1;
+   .google.protobuf.Timestamp When = 2;
+}
+message MyResponse {
+   string Value = 1;
+   Category Category = 2;
+   string RefId = 3; // default value could not be applied: 00000000-0000-0000-0000-000000000000
+}
+service MyService {
+   rpc AsyncEmpty (.google.protobuf.Empty) returns (.google.protobuf.Empty);
+   rpc ClientStreaming (MyResponse) returns (stream MyRequest);
+   rpc FullDuplex (stream MyResponse) returns (stream MyRequest);
+   rpc ServerStreaming (stream MyResponse) returns (MyRequest);
+   rpc SyncEmpty (.google.protobuf.Empty) returns (.google.protobuf.Empty);
+   rpc Unary (MyResponse) returns (MyRequest);
+}
+", schema, ignoreLineEndingDifferences: true);
+        }
+
+        [ServiceContract]
+        public interface IMyService
+        {
+            ValueTask<MyResponse> Unary(MyRequest request, CallContext callContext = default);
+            ValueTask<MyResponse> ClientStreaming(IAsyncEnumerable<MyRequest> request, CallContext callContext = default);
+            IAsyncEnumerable<MyResponse> ServerStreaming(MyRequest request, CallContext callContext = default);
+            IAsyncEnumerable<MyResponse> FullDuplex(IAsyncEnumerable<MyRequest> request, CallContext callContext = default);
+
+            ValueTask AsyncEmpty();
+            void SyncEmpty();
+        }
+
+        [DataContract]
+        public class MyRequest
+        {
+            [DataMember(Order = 1)]
+            public int Id { get; set; }
+
+            // with protobuf-net v3, this could use DataContract/DataMember throughput, and
+            // just use CompatibilityLevel 300+
+            [DataMember(Order = 2)]
+            public DateTime When { get; set; }
+        }
+
+        [DataContract]
+        public class MyResponse
+        {
+            [DataMember(Order = 1)]
+            public string? Value { get; set; }
+
+            [DataMember(Order = 2)]
+            public Category Category {get;set;}
+
+            [DataMember(Order = 3)]
+            public Guid RefId { get; set; }
+        }
+
+        public enum Category
+    {
+            Default = 0,
+            Foo = 1,
+            Bar = 2,
+        }
+    }
+}

tests/protobuf-net.Grpc.Test.IntegrationUpLevel/protobuf-net.Grpc.Test.IntegrationUpLevel.csproj

@@ -11,7 +11,7 @@
 
 	<ItemGroup>
 		<PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.6.1" />
-		<PackageReference Include="protobuf-net" Version="3.0.2" />
+		<PackageReference Include="protobuf-net" Version="3.0.21" />
 		<PackageReference Include="System.Collections.Immutable" Version="1.7.1" />
 		<PackageReference Include="xunit" Version="2.4.1" />
 		<PackageReference Include="xunit.runner.visualstudio" Version="2.4.2">

tests/protobuf-net.Grpc.Test/ContractOperationTests.cs

@@ -62,7 +62,7 @@ public void ServerSignatureCount()
         }
 
         [Fact]
-        public void CheckAllMethodsConvered()
+        public void CheckAllMethodsCovered()
         {
             var expected =  new HashSet<string>(typeof(IAllOptions).GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).Select(x => x.Name));
             Assert.Equal(ContractOperation.SignatureCount, expected.Count);