Initial implementation of plugins

src/Temporalio/Client/ITemporalClientPlugin.cs

@@ -0,0 +1,33 @@
+using System;
+using System.Threading.Tasks;
+
+namespace Temporalio.Client
+{
+    /// <summary>
+    /// Interface for temporal client plugins.
+    /// </summary>
+    /// <remarks>
+    /// WARNING: This API is experimental and may change in the future.
+    /// </remarks>
+    public interface ITemporalClientPlugin
+    {
+        /// <summary>
+        /// Gets the plugin name.
+        /// </summary>
+        public string Name { get; }
+
+        /// <summary>
+        /// Configures the client options.
+        /// </summary>
+        /// <param name="options">The client options to configure.</param>
+        public void ConfigureClient(TemporalClientOptions options);
+
+        /// <summary>
+        /// Handles temporal connection asynchronously.
+        /// </summary>
+        /// <param name="options">The connection options.</param>
+        /// <param name="continuation">The continuation function.</param>
+        /// <returns>A task representing the asynchronous operation.</returns>
+        public Task<TemporalConnection> TemporalConnectAsync(TemporalClientConnectOptions options, Func<TemporalClientConnectOptions, Task<TemporalConnection>> continuation);
+    }
+}

src/Temporalio/Client/TemporalClient.cs

@@ -21,6 +21,11 @@ public partial class TemporalClient : ITemporalClient
         /// <param name="options">Options for this client.</param>
         public TemporalClient(ITemporalConnection connection, TemporalClientOptions options)
         {
+            foreach (var plugin in options.Plugins ?? Enumerable.Empty<ITemporalClientPlugin>())
+            {
+                plugin.ConfigureClient(options);
+            }
+
             Connection = connection;
             Options = options;
             OutboundInterceptor = new Impl(this);
@@ -61,10 +66,21 @@ public TemporalClient(ITemporalConnection connection, TemporalClientOptions opti
         /// <param name="options">Options for connecting.</param>
         /// <returns>The connected client.</returns>
         public static async Task<TemporalClient> ConnectAsync(
-            TemporalClientConnectOptions options) =>
-            new(
-                await TemporalConnection.ConnectAsync(options).ConfigureAwait(false),
+            TemporalClientConnectOptions options)
+        {
+            Func<TemporalClientConnectOptions, Task<TemporalConnection>> connect = TemporalConnection.ConnectAsync;
+            if (options.Plugins != null)
+            {
+                foreach (var plugin in options.Plugins.Reverse())
+                {
+                    var localConnect = connect;
+                    connect = connectOptions => plugin.TemporalConnectAsync(connectOptions, localConnect);
+                }
+            }
+            return new(
+                await connect(options).ConfigureAwait(false),
                 options.ToClientOptions());
+        }
 
         /// <summary>
         /// Create a client to a Temporal namespace that does not connect until first call.

src/Temporalio/Client/TemporalClientConnectOptions.cs

@@ -66,6 +66,14 @@ public TemporalClientConnectOptions(string targetHost)
         /// </summary>
         public QueryRejectCondition? QueryRejectCondition { get; set; }
 
+        /// <summary>
+        /// Gets or sets the plugins.
+        /// </summary>
+        /// <remarks>
+        /// WARNING: This API is experimental and may change in the future.
+        /// </remarks>
+        public IReadOnlyCollection<ITemporalClientPlugin>? Plugins { get; set; }
+
         /// <summary>
         /// Create client options from a subset of these options for use in
         /// <see cref="TemporalClient.TemporalClient" />.

src/Temporalio/Client/TemporalClientOptions.cs

@@ -43,6 +43,14 @@ public class TemporalClientOptions : ICloneable
         /// </summary>
         public QueryRejectCondition? QueryRejectCondition { get; set; }
 
+        /// <summary>
+        /// Gets or sets the plugins.
+        /// </summary>
+        /// <remarks>
+        /// WARNING: This API is experimental and may change in the future.
+        /// </remarks>
+        public IReadOnlyCollection<ITemporalClientPlugin>? Plugins { get; set; }
+
         /// <summary>
         /// Create a shallow copy of these options.
         /// </summary>

src/Temporalio/Common/SimplePlugin.cs

@@ -0,0 +1,167 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Temporalio.Client;
+using Temporalio.Worker;
+
+namespace Temporalio.Common
+{
+    /// <summary>
+    /// A simple plugin that implements both client and worker plugin interfaces.
+    /// </summary>
+    /// <remarks>
+    /// WARNING: This API is experimental and may change in the future.
+    /// </remarks>
+    public class SimplePlugin : ITemporalClientPlugin, ITemporalWorkerPlugin
+    {
+        /// <summary>
+        /// The plugin options.
+        /// </summary>
+        private readonly SimplePluginOptions pluginOptions;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="SimplePlugin"/> class.
+        /// </summary>
+        /// <param name="name">The plugin name.</param>
+        /// <param name="options">The plugin options.</param>
+        public SimplePlugin(
+            string name,
+            SimplePluginOptions options)
+        {
+            Name = name;
+            pluginOptions = options;
+        }
+
+        /// <summary>
+        /// Gets the plugin name.
+        /// </summary>
+        public string Name { get; }
+
+        /// <summary>
+        /// Configures the client options.
+        /// </summary>
+        /// <param name="options">The client options to configure.</param>
+        public virtual void ConfigureClient(TemporalClientOptions options)
+        {
+            options.DataConverter = Resolve(options.DataConverter, pluginOptions.DataConverterOption);
+            options.Interceptors = ResolveAppend(options.Interceptors, pluginOptions.ClientInterceptorsOption);
+        }
+
+        /// <summary>
+        /// Handles temporal connection asynchronously.
+        /// </summary>
+        /// <param name="options">The connection options.</param>
+        /// <param name="continuation">The continuation function.</param>
+        /// <returns>A task representing the asynchronous operation.</returns>
+        public virtual Task<TemporalConnection> TemporalConnectAsync(
+            TemporalClientConnectOptions options,
+            Func<TemporalClientConnectOptions, Task<TemporalConnection>> continuation)
+        {
+            return continuation(options);
+        }
+
+        /// <summary>
+        /// Configures the worker options.
+        /// </summary>
+        /// <param name="options">The worker options to configure.</param>
+        public virtual void ConfigureWorker(TemporalWorkerOptions options)
+        {
+            DoAppend(options.Activities, pluginOptions.Activities);
+            DoAppend(options.Workflows, pluginOptions.Workflows);
+            DoAppend(options.NexusServices, pluginOptions.NexusServices);
+            options.Interceptors = ResolveAppend(options.Interceptors, pluginOptions.WorkerInterceptorsOption);
+            options.WorkflowFailureExceptionTypes = ResolveAppend(options.WorkflowFailureExceptionTypes, pluginOptions.WorkflowFailureExceptionTypesOption);
+        }
+
+        /// <summary>
+        /// Runs the worker asynchronously.
+        /// </summary>
+        /// <param name="worker">The worker to run.</param>
+        /// <param name="continuation">The continuation function.</param>
+        /// <returns>A task representing the asynchronous operation.</returns>
+        public virtual Task RunWorkerAsync(TemporalWorker worker, Func<TemporalWorker, Task> continuation)
+        {
+            return continuation(worker);
+        }
+
+        /// <summary>
+        /// Configures the replayer options.
+        /// </summary>
+        /// <param name="options">The replayer options to configure.</param>
+        public virtual void ConfigureReplayer(WorkflowReplayerOptions options)
+        {
+            options.DataConverter = Resolve(options.DataConverter, pluginOptions.DataConverterOption);
+            DoAppend(options.Workflows, pluginOptions.Workflows);
+            options.Interceptors = ResolveAppend(options.Interceptors, pluginOptions.WorkerInterceptorsOption);
+            options.WorkflowFailureExceptionTypes = ResolveAppend(options.WorkflowFailureExceptionTypes, pluginOptions.WorkflowFailureExceptionTypesOption);
+        }
+
+        /// <summary>
+        /// Runs the replayer asynchronously.
+        /// </summary>
+        /// <param name="replayer">The replayer to run.</param>
+        /// <param name="continuation">The continuation function.</param>
+        /// <returns>A task representing the asynchronous operation.</returns>
+        public virtual Task<IEnumerable<WorkflowReplayResult>> RunReplayerAsync(
+            WorkflowReplayer replayer,
+            Func<WorkflowReplayer, Task<IEnumerable<WorkflowReplayResult>>> continuation)
+        {
+            return continuation(replayer);
+        }
+
+        private static T Resolve<T>(T existing, SimplePluginOptions.SimplePluginRequiredOption<T>? parameter)
+        {
+            if (parameter == null)
+            {
+                return existing;
+            }
+            var option = parameter.Constant ?? existing;
+            if (parameter.Configurable != null)
+            {
+                return parameter.Configurable(option);
+            }
+            return option;
+        }
+
+        private static IReadOnlyCollection<T>? ResolveAppend<T>(
+            IReadOnlyCollection<T>? existing,
+            SimplePluginOptions.SimplePluginOption<IReadOnlyCollection<T>>? parameter)
+        {
+            if (parameter == null)
+            {
+                return existing;
+            }
+
+            var option = existing;
+            if (existing != null && parameter.Constant != null)
+            {
+                option = existing.Concat(parameter.Constant).ToList();
+            }
+            else if (parameter.Constant != null)
+            {
+                option = parameter.Constant;
+            }
+            if (parameter.Configurable != null)
+            {
+                return parameter.Configurable(option);
+            }
+            return option;
+        }
+
+        private static void DoAppend<T>(
+            IList<T> existing,
+            IList<T>? parameter)
+        {
+            if (parameter == null)
+            {
+                return;
+            }
+
+            foreach (var item in parameter)
+            {
+                existing.Add(item);
+            }
+        }
+    }
+}