feat: Implement strongly typed function signatures for dotnet

Author: garethgeorge

src/Google.Cloud.Functions.Framework.Tests/TypedFunctionAdapterTest.cs

@@ -0,0 +1,99 @@
+// Copyright 2023, Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.Logging.Abstractions;
+using System;
+using System.Globalization;
+using System.IO;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace Google.Cloud.Functions.Framework.Tests;
+
+public class TypedFunctionAdapterTest
+{
+    [Fact]
+    public async Task InvalidRequest_400BadRequestError()
+    {
+        var adapter = new TypedFunctionAdapter<string, int>(
+            new TestTypedFunction(),
+            new AlwaysFailsToParseRequestReader(),
+            new Int32ResponseWriter(),
+            new NullLogger<TypedFunctionAdapter<string, int>>()
+        );
+        var context = new DefaultHttpContext();
+        await adapter.HandleAsync(context);
+        Assert.Equal(400, context.Response.StatusCode);
+    }
+
+    [Fact]
+    public async Task TestRequest_ExecutesFunction()
+    {
+        var payload = "Hello World!";
+
+        var adapter = new TypedFunctionAdapter<string, int>(
+            new TestTypedFunction(),
+            new StringRequestReader(),
+            new Int32ResponseWriter(),
+            new NullLogger<TypedFunctionAdapter<string, int>>()
+        );
+
+        var context = new DefaultHttpContext
+        {
+            Request =
+        {
+            ContentType = "text/plain",
+            Body = new MemoryStream(Encoding.UTF8.GetBytes(payload)),
+        },
+            Response =
+        {
+            Body = new MemoryStream(),
+        }
+        };
+
+        await adapter.HandleAsync(context);
+        Assert.Equal(200, context.Response.StatusCode);
+        context.Response.Body.Position = 0;
+        // The function counts the number of characters in the payload,
+        // and returns a text representation of that number.
+        Assert.Equal("12", new StreamReader(context.Response.Body).ReadToEnd());
+    }
+
+    class TestTypedFunction : ITypedFunction<string, int>
+    {
+        public Task<int> HandleAsync(string request, CancellationToken cancellationToken) =>
+            Task.FromResult(request.Length);
+    }
+
+    class StringRequestReader : IHttpRequestReader<string>
+    {
+        public Task<string> ReadRequestAsync(HttpRequest request) =>
+            new StreamReader(request.Body).ReadToEndAsync();
+    }
+
+    class Int32ResponseWriter : IHttpResponseWriter<int>
+    {
+        public Task WriteResponseAsync(HttpResponse httpResponse, int functionResponse) =>
+            httpResponse.WriteAsync(functionResponse.ToString(CultureInfo.InvariantCulture));
+    }
+
+    class AlwaysFailsToParseRequestReader : IHttpRequestReader<string>
+    {
+        public Task<string> ReadRequestAsync(HttpRequest request) =>
+            Task.FromException<string>(new Exception("Injected parse failure"));
+    }
+}

src/Google.Cloud.Functions.Framework/IHttpRequestReader.cs

@@ -0,0 +1,31 @@
+// Copyright 2023, Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using Microsoft.AspNetCore.Http;
+using System.Threading.Tasks;
+
+namespace Google.Cloud.Functions.Framework;
+
+/// <summary>
+/// Responsible for reading a strongly typed request object from an
+/// HTTP request.
+/// </summary>
+public interface IHttpRequestReader<TRequest>
+{
+    /// <summary>
+    /// Asynchronously reads a strongly typed request object.
+    /// </summary>
+    /// <returns>A task representing the asynchronous operation.</returns>
+    public Task<TRequest> ReadRequestAsync(HttpRequest httpRequest);
+}

src/Google.Cloud.Functions.Framework/IHttpResponseWriter.cs

@@ -0,0 +1,32 @@
+// Copyright 2023, Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using Microsoft.AspNetCore.Http;
+using System.Threading.Tasks;
+
+namespace Google.Cloud.Functions.Framework;
+
+/// <summary>
+/// Responsible for writing a strongly typed response object to an
+/// HTTP response.
+/// </summary>
+public interface IHttpResponseWriter<TResponse>
+{
+    /// <summary>
+    /// Asynchronously writes a strongly typed response object to
+    /// an HTTP response.
+    /// </summary>
+    /// <returns>A task representing the asynchronous operation.</returns>
+    Task WriteResponseAsync(HttpResponse httpResponse, TResponse functionResponse);
+}

src/Google.Cloud.Functions.Framework/ITypedFunction.cs

@@ -0,0 +1,36 @@
+// Copyright 2023, Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Google.Cloud.Functions.Framework;
+
+/// <summary>
+/// A typed function accepting a structured request and asynchronously 
+/// returning a structured response.
+/// </summary>
+/// <typeparam name="TRequest">Type of the request object.</typeparam>
+/// <typeparam name="TResponse">Type of the response object.</typeparam>
+public interface ITypedFunction<TRequest, TResponse>
+{
+    /// <summary>
+    /// Asynchronously handles an incoming request, expected to return 
+    /// a structured response.
+    /// </summary>
+    /// <param name="request">The request payload, deserialized from the incoming request.</param>
+    /// <param name="cancellationToken">A cancellation token which indicates if the request is aborted.</param>
+    /// <returns>A task representing the asynchronous operation.</returns>
+    Task<TResponse> HandleAsync(TRequest request, CancellationToken cancellationToken);
+}

src/Google.Cloud.Functions.Framework/TypedFunctionAdapter.cs

@@ -0,0 +1,81 @@
+// Copyright 2023, Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.Logging;
+using System;
+using System.Threading.Tasks;
+
+namespace Google.Cloud.Functions.Framework;
+
+/// <summary>
+/// An adapter to implement an HTTP Function based on a <see cref="ITypedFunction{TRequest, TResponse}"/>,
+/// with built-in request deserialization and response serialization.
+/// </summary>
+public sealed class TypedFunctionAdapter<TRequest, TResult> : IHttpFunction
+{
+    private readonly ITypedFunction<TRequest, TResult> _function;
+    private readonly IHttpRequestReader<TRequest> _requestReader;
+    private readonly IHttpResponseWriter<TResult> _responseWriter;
+    private readonly ILogger _logger;
+
+    /// <summary>
+    /// Constructs a new instance based on the given TypedFunction.
+    /// </summary>
+    public TypedFunctionAdapter(
+        ITypedFunction<TRequest, TResult> function,
+        IHttpRequestReader<TRequest> requestReader,
+        IHttpResponseWriter<TResult> responseWriter,
+        ILogger<TypedFunctionAdapter<TRequest, TResult>> logger)
+    {
+        _function = Preconditions.CheckNotNull(function, nameof(function));
+        _requestReader = Preconditions.CheckNotNull(requestReader, nameof(requestReader));
+        _responseWriter = Preconditions.CheckNotNull(responseWriter, nameof(responseWriter));
+        _logger = Preconditions.CheckNotNull(logger, nameof(logger));
+    }
+
+    /// <summary>
+    /// Handles an HTTP request by extracting the CloudEvent from it, deserializing the data, and passing
+    /// both the event and the data to the original CloudEvent Function.
+    /// The request fails if it does not contain a CloudEvent.
+    /// </summary>
+    /// <param name="context">The HTTP context containing the request and response.</param>
+    /// <returns>A task representing the asynchronous operation.</returns>
+    public async Task HandleAsync(HttpContext context)
+    {
+        TRequest data;
+        try
+        {
+            data = await _requestReader.ReadRequestAsync(context.Request);
+        }
+        catch (Exception e)
+        {
+            _logger.LogError(e, e.Message);
+            context.Response.StatusCode = StatusCodes.Status400BadRequest;
+            return;
+        }
+
+        TResult res = await _function.HandleAsync(data, context.RequestAborted);
+        try
+        {
+            await _responseWriter.WriteResponseAsync(context.Response, res);
+        }
+        catch (Exception e)
+        {
+            _logger.LogError(e, e.Message);
+            context.Response.StatusCode = StatusCodes.Status500InternalServerError;
+            return;
+        }
+    }
+}