feat: upgrade to Fusion 6.1.110!

Author: alexyakunin

Samples.sln

@@ -29,8 +29,6 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Common", "src\Caching\Commo
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Client", "src\Caching\Client\Client.csproj", "{C2B70735-480E-4B22-9DF1-8AFAC2C0F634}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Client", "src\Blazor\Client\Client.csproj", "{D6FEBDE1-2FF2-4354-A500-692DD41FA1CA}"
-EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ConsoleClient", "src\Blazor\ConsoleClient\ConsoleClient.csproj", "{AB5D5E44-4E90-48BA-BF15-1108C3950550}"
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HelloCart", "src\HelloCart\HelloCart.csproj", "{B36E4A0D-11B7-4F54-8E98-2A9D1C4E6F2E}"
@@ -81,7 +79,6 @@ Global
 		{C736B632-999C-475A-9556-36CF49E64A00} = {E3EFB37C-E523-44D0-ADC9-DE1257A19125}
 		{F158690D-69C5-4502-A8CE-E462660BE35F} = {E3EFB37C-E523-44D0-ADC9-DE1257A19125}
 		{C2B70735-480E-4B22-9DF1-8AFAC2C0F634} = {E3EFB37C-E523-44D0-ADC9-DE1257A19125}
-		{D6FEBDE1-2FF2-4354-A500-692DD41FA1CA} = {9B29BD3F-7D94-4936-8379-61A2F48259AF}
 		{AB5D5E44-4E90-48BA-BF15-1108C3950550} = {9B29BD3F-7D94-4936-8379-61A2F48259AF}
 		{B36E4A0D-11B7-4F54-8E98-2A9D1C4E6F2E} = {B5A8469D-C4BB-4808-8E44-FF4DFCA57BDE}
 		{60EEDA0D-791F-4195-BE7C-D1E04C66B4FC} = {B5A8469D-C4BB-4808-8E44-FF4DFCA57BDE}
@@ -134,10 +131,6 @@ Global
 		{C2B70735-480E-4B22-9DF1-8AFAC2C0F634}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{C2B70735-480E-4B22-9DF1-8AFAC2C0F634}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{C2B70735-480E-4B22-9DF1-8AFAC2C0F634}.Release|Any CPU.Build.0 = Release|Any CPU
-		{D6FEBDE1-2FF2-4354-A500-692DD41FA1CA}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{D6FEBDE1-2FF2-4354-A500-692DD41FA1CA}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{D6FEBDE1-2FF2-4354-A500-692DD41FA1CA}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{D6FEBDE1-2FF2-4354-A500-692DD41FA1CA}.Release|Any CPU.Build.0 = Release|Any CPU
 		{AB5D5E44-4E90-48BA-BF15-1108C3950550}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{AB5D5E44-4E90-48BA-BF15-1108C3950550}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{AB5D5E44-4E90-48BA-BF15-1108C3950550}.Release|Any CPU.ActiveCfg = Release|Any CPU

docs/tutorial/Fusion-Cheat-Sheet.md

@@ -43,66 +43,25 @@ using (Computed.Invalidate()) {
 Register compute service:
 ```cs
 fusion = services.AddFusion(); // services is IServiceCollection
-fusion.AddComputeService<ICartService, CartService>();
+fusion.AddService<ICartService, CartService>();
 ```
 
-## Replica Services
+## Compute Service Clients
 
-Add controller:
-```cs
-[Route("api/[controller]/[action]")]
-[ApiController, JsonifyErrors, UseDefaultSession]
-public class CartController : ControllerBase, ICartService
-{
-    private readonly ICartService _cartService;
-    private readonly ICommander _commander;
-
-    public CartController(ICartService service, ICommander commander) 
-    {
-        _service = service;
-        _commander = commander;
-    }    
-
-    [HttpGet, Publish]
-    public Task<List<Order>> GetOrders(long cartId, CancellationToken cancellationToken)
-        => _service.GetOrders(cartId, cancellationToken);
-}
-```
-
-Add client definition:
-```cs
-[BasePath("cart")]
-public interface ICartClientDef
-{
-    [Get(nameof(GetOrders))]
-    Task<List<Order>> GetOrders(long cartId, CancellationToken cancellationToken);
-}
-```
-
-Configure Fusion client (this has to be done once in a code that configures client-side `IServiceProvider`):
+Configure Fusion RPC client (this has to be done once in a code that configures client-side `IServiceProvider`):
 ```cs
 var baseUri = new Uri("http://localhost:5005");
-var apiBaseUri = new Uri($"{baseUri}api/");
 
 var fusion = services.AddFusion();
-var fusionClient = fusion.AddRestEaseClient(
-    client => {
-        client.ConfigureWebSocketChannel(_ => new() { BaseUri = baseUri });
-        client.ConfigureHttpClient((_, name, o) => {
-            var isFusionClient = (name ?? "").StartsWith("Stl.Fusion");
-            var clientBaseUri = isFusionClient ? baseUri : apiBaseUri;
-            o.HttpClientActions.Add(httpClient => httpClient.BaseAddress = clientBaseUri);
-        });
-    });
+fusion.Rpc.AddWebSocketClient(baseUri);
 ```
 
-Register Replica Service:
+Register Compute Service client:
 ```cs
-// After "var fusionClient = ..."
-fusionClient.AddReplicaService<ICartService, ICartClientDef>();
+fusion.AddClient<ICartService>();
 ```
 
-Use Replica Service:
+Use use it:
 ```cs
 // Just call it the same way you call the original one.
 // Any calls that are expected to produce the same result
@@ -166,7 +125,7 @@ Register command handler:
 // Nothing is needed for handlers declared inside compute services
 ```
 
-## Exposing commands to the client via Replica Services
+## Exposing commands to the client via Compute Service Clients
 
 Add controller method for the command:
 ```cs
@@ -182,25 +141,11 @@ public class CartController : ControllerBase, ICartService
         => _commander.Call(command, cancellationToken);
 ```        
 
-Add command handler in the client definition interface:
-```cs
-public interface ICartClientDef 
-{
-    // Always use [Post] and [Body] here
-    [Post(nameof(UpdateCart))]
-    Task<Unit> UpdateCart([Body] UpdateCartCommand command, CancellationToken cancellationToken);
-```        
-
-Register client-side command handler:
-```
-// Nothing is needed for handlers declared inside replica services
-```
-
 ## Working with `IComputed`
 
 Capture:
 ```cs
-var computed = await Computed.Capture(ct => service.ComputeMethod(args, ct), cancellationToken);
+var computed = await Computed.Capture(() => service.ComputeMethod(args, cancellationToken));
 ```
 
 Check whether `IComputed` is still consistent:

docs/tutorial/Part00.md

@@ -17,49 +17,62 @@ Your should reference:
 * `Stl.Fusion.EntityFramework` – from server-side assemblies,
   if you plan to use [EF Core](https://docs.microsoft.com/en-us/ef/).
 
-The full list of Fusion packages:
+The list of Fusion packages:
 
 * [Stl](https://www.nuget.org/packages/Stl/) - stands for "ServiceTitan Library"
   (yeah, every company needs its own [STL](https://en.wikipedia.org/wiki/Standard_Template_Library)).
   It's a collection of relatively isolated abstractions and helpers we couldn't find in BCL.
   `Stl` depends on [Castle.Core](https://www.nuget.org/packages/Castle.Core/) & maybe some other
   third-party packages.
-* [Stl.Net](https://www.nuget.org/packages/Stl.Net/) - depends on `Stl`.
-  [WebSocketChannel](https://github.com/servicetitan/Stl.Fusion/blob/master/src/Stl.Net/WebSocketChannel.cs)
-  is currently the only type it contains.
+* [Stl.Generators](https://www.nuget.org/packages/Stl.Generators/) - has no dependencies.
+  It's a Roslyn-based code generation library focused on proxies / call interception.
+  All Fusion proxies are implemented with it. 
 * [Stl.Interception](https://www.nuget.org/packages/Stl.Interception/) - depends on `Stl`.
-  Call interception helpers based on [Castle DynamicProxy](http://www.castleproject.org/projects/dynamicproxy/).
+  Implements a number of call interception helpers which are used by [Stl.Generators].
+* [Stl.Rpc](https://www.nuget.org/packages/Stl.Rpc/) - depends on `Stl`.
+  An RPC API that Fusion uses to implement Compute Service Clients.
+  It's probably the fastest RPC implementation over WebSockets that's currently available on .NET - even for plain RPC calls.
+* [Stl.Rpc.Server](https://www.nuget.org/packages/Stl.Rpc.Server/) - depends on `Stl.Rpc`.
+  An implementation of `Stl.Rpc` server for ASP.NET Core, which uses WebSockets.
+* [Stl.Rpc.Server.NetFx](https://www.nuget.org/packages/Stl.Rpc.Server.NetFx/) - depends on `Stl.Rpc`.
+  An implementation of `Stl.Rpc` server for ASP.NET / .NET Framework 4.X, which uses WebSockets.
 * [Stl.CommandR](https://www.nuget.org/packages/Stl.CommandR/) - depends on `Stl` and `Stl.Interception`.
   CommandR is "[MediatR](hhttps://github.com/jbogard/MediatR) on steroids" designed to support
   not only interface-based command handlers, but also AOP-style handlers written as
   regular methods. Besides that, it unifies command handler API (pipeline behaviors and handlers
   are the same there) and helps to eliminate nearly all boilerplate code you'd have otherwise.
 * [Stl.Fusion](https://www.nuget.org/packages/Stl.Fusion/) - depends on `Stl`, `Stl.Interception`, and `Stl.CommandR`.
   Nearly everything related to Fusion is there.
-* [Stl.Fusion.Server](https://www.nuget.org/packages/Stl.Fusion.Server/) - depends on `Stl.Fusion` and `Stl.Net`.
-  It implements server-side WebSocket endpoint allowing client-side counterpart to communicate
-  with Fusion `Publisher`. In addition, it provides a base class for fusion API controllers
-  (`FusionController`) and a few extension methods helping to register all of that in your web app.
+* [Stl.Fusion.Ext.Contracts](https://www.nuget.org/packages/Stl.Fusion.Ext.Contracts/) - depends on `Stl.Fusion`.
+  Contracts for some handy extensions (ready-to-use Fusion services) - e.g. Fusion-based authentication is there.
+* [Stl.Fusion.Ext.Services](https://www.nuget.org/packages/Stl.Fusion.Ext.Services/) - depends on `Stl.Fusion.Ext.Contracts` and `Stl.Fusion.EntityFramework`.
+  Implementations of extension contracts from `Stl.Fusion.Ext.Contracts`.
+* [Stl.Fusion.Server](https://www.nuget.org/packages/Stl.Fusion.Server/) - depends on `Stl.Fusion` and `Stl.Rpc`.
+  Basically, Fusion + `Stl.Rpc.Server` + some handy server-side helpers.
 * [Stl.Fusion.Server.NetFx](https://www.nuget.org/packages/Stl.Fusion.Server.NetFx/) -
   .NET Framework 4.X version of `Stl.Fusion.Server`.
-* [Stl.Fusion.Client](https://www.nuget.org/packages/Stl.Fusion.Client/) - depends on `Stl.Fusion` and `Stl.Net`.
-  Implements a client-side WebSocket communication channel and
-  [RestEase](https://github.com/canton7/RestEase) - based API client builder compatible with
-  `FusionControler`-based API endpoints. All of that together allows you to get computed
-  instances on the client that "mirror" their server-side counterparts.
-* [Stl.Fusion.Blazor](https://www.nuget.org/packages/Stl.Fusion.Blazor/) - depends on `Stl.Fusion.Client`.
-  Implements handy Blazor components. Currently there is `StatefulCompontentBase<TState>`
-  and its 2 descendants: `ComputedStateComponent<T>` and `ComputedStateComponent<T, TLocals>`.
+* [Stl.Fusion.Blazor](https://www.nuget.org/packages/Stl.Fusion.Blazor/) - depends on `Stl.Fusion`.
+  Provides Blazor-Fusion integration. Most importantly, there is `StatefulCompontentBase<TState>`,
+  which allows to create auto-updating components which recompute their state once the data they consume
+  from Fusion services changes.
+* [Stl.Fusion.Blazor.Authentication](https://www.nuget.org/packages/Stl.Fusion.Blazor.Authentication/) - depends on `Stl.Fusion.Blazor` and `Stl.Fusion.Ext.Contracts`.
+  Implements Fusion authentication-related Blazor components.
 * [Stl.Fusion.EntityFramework](https://www.nuget.org/packages/Stl.Fusion.EntityFramework/) - depends on `Stl.Fusion`.
-  Contains [EF Core](https://docs.microsoft.com/en-us/ef/) - based implementation of
-  Fusion authentication, operation persistence, `IKeyValueStore`, etc.
+  Contains [EF Core](https://docs.microsoft.com/en-us/ef/) integrations for CommandR and Fusion.
 * [Stl.Fusion.EntityFramework.Npgsql](https://www.nuget.org/packages/Stl.Fusion.EntityFramework.Npgsql/) -
   depends on `Stl.Fusion.EntityFramework`.  
   Contains [Npgsql](https://www.npgsql.org/) - based implementation of operation log change tracking.
   PostgreSQL has [`NOTIFY / LISTEN`](https://www.postgresql.org/docs/13/sql-notify.html)
   commands allowing to use it as a message queue, so if you use this database,
   you don't need a separate message queue to allow Fusion to notify peer hosts about
   operation log changes.
+* [Stl.Fusion.EntityFramework.Redis](https://www.nuget.org/packages/Stl.Fusion.EntityFramework.Redis/) -
+  depends on `Stl.Fusion.EntityFramework`.  
+  Contains [Redis](https://redis.com/) - based implementation of operation log change tracking.
 
-#### [Next: Part 1 &raquo;](./Part01.md) | [Tutorial Home](./README.md)
+There are some other packages, but more likely than not you won't need them. 
+The complete list can be found here (the packages with the most recent version aren't obsolete): 
+- https://www.nuget.org/packages?q=Tags%3A%22stl_fusion%22 
 
+
+#### [Next: Part 1 &raquo;](./Part01.md) | [Tutorial Home](./README.md)

docs/tutorial/Part01.cs

@@ -2,7 +2,6 @@
 using System.Collections.Concurrent;
 using System.Threading.Tasks;
 using Microsoft.Extensions.DependencyInjection;
-using Stl.Async;
 using Stl.Fusion;
 using static System.Console;
 
@@ -15,15 +14,15 @@ public static IServiceProvider CreateServices()
         {
             var services = new ServiceCollection();
             var fusion = services.AddFusion();
-            fusion.AddComputeService<CounterService>();
-            fusion.AddComputeService<CounterSumService>(); // We'll be using it later
-            fusion.AddComputeService<HelloService>();      // We'll be using it later
+            fusion.AddService<CounterService>();
+            fusion.AddService<CounterSumService>(); // We'll be using it later
+            fusion.AddService<HelloService>();      // We'll be using it later
             return services.BuildServiceProvider();
         }
         #endregion
 
         #region Part01_CounterService
-        public class CounterService
+        public class CounterService : IComputeService
         {
             private readonly ConcurrentDictionary<string, int> _counters = new ConcurrentDictionary<string, int>();
 
@@ -73,7 +72,7 @@ public static async Task UseCounterService3()
         }
 
         #region Part01_CounterSumService
-        public class CounterSumService
+        public class CounterSumService : IComputeService
         {
             public CounterService Counters { get; }
 
@@ -125,7 +124,7 @@ public static async Task UseCounterSumService3()
         }
 
         #region Part01_HelloService
-        public class HelloService
+        public class HelloService : IComputeService
         {
             [ComputeMethod]
             public virtual async Task<string> Hello(string name)

docs/tutorial/Part01.md

@@ -33,17 +33,17 @@ public static IServiceProvider CreateServices()
 {
     var services = new ServiceCollection();
     var fusion = services.AddFusion();
-    fusion.AddComputeService<CounterService>();
-    fusion.AddComputeService<CounterSumService>(); // We'll be using it later
-    fusion.AddComputeService<HelloService>();      // We'll be using it later
+    fusion.AddService<CounterService>();
+    fusion.AddService<CounterSumService>(); // We'll be using it later
+    fusion.AddService<HelloService>();      // We'll be using it later
     return services.BuildServiceProvider();
 }
 ```
 
 Now we're ready to declare our first Compute Service:
 
 ``` cs --editable false --region Part01_CounterService --source-file Part01.cs
-public class CounterService
+public class CounterService : IComputeService
 {
     private readonly ConcurrentDictionary<string, int> _counters = new ConcurrentDictionary<string, int>();
 
@@ -137,7 +137,7 @@ it was printed just for the first call.
 Now let's add another Compute Service:
 
 ``` cs --editable false --region Part01_CounterSumService --source-file Part01.cs
-public class CounterSumService
+public class CounterSumService : IComputeService
 {
     public CounterService Counters { get; }
 
@@ -255,7 +255,7 @@ To close this section, let's look at the last property closer.
 Let's create a simple service to test how Fusion handles concurrency:
 
 ``` cs --editable false --region Part01_HelloService --source-file Part01.cs
-public class HelloService
+public class HelloService : IComputeService
 {
     [ComputeMethod]
     public virtual async Task<string> Hello(string name)
@@ -321,4 +321,3 @@ Overall, nearly everything in Fusion supports concurrent invocations:
   as types that aren't supposed to be concurrent (e.g. all Blazor components - `StatefulComponentBase<TState>` and its descendants).
 
 #### [Next: Part 2 &raquo;](./Part02.md) | [Tutorial Home](./README.md)
-

docs/tutorial/Part02.cs

@@ -2,7 +2,6 @@
 using System.Collections.Concurrent;
 using System.Threading.Tasks;
 using Microsoft.Extensions.DependencyInjection;
-using Stl.Async;
 using Stl.Fusion;
 using static System.Console;
 
@@ -11,7 +10,7 @@ namespace Tutorial
     public static class Part02
     {
         #region Part02_CounterService
-        public class CounterService
+        public class CounterService : IComputeService
         {
             private readonly ConcurrentDictionary<string, int> _counters = new ConcurrentDictionary<string, int>();
 
@@ -35,7 +34,7 @@ public static IServiceProvider CreateServices()
         {
             var services = new ServiceCollection();
             var fusion = services.AddFusion();
-            fusion.AddComputeService<CounterService>();
+            fusion.AddService<CounterService>();
             return services.BuildServiceProvider();
         }
         #endregion

docs/tutorial/Part02.md

@@ -14,7 +14,7 @@ We're going to use the same `CounterService` and `CreateServices` helper
 as in Part 1:
 
 ``` cs --editable false --region Part02_CounterService --source-file Part02.cs
-public class CounterService
+public class CounterService : IComputeService
 {
     private readonly ConcurrentDictionary<string, int> _counters = new ConcurrentDictionary<string, int>();
 
@@ -38,7 +38,7 @@ public static IServiceProvider CreateServices()
 {
     var services = new ServiceCollection();
     var fusion = services.AddFusion();
-    fusion.AddComputeService<CounterService>();
+    fusion.AddService<CounterService>();
     return services.BuildServiceProvider();
 }
 ```
@@ -341,4 +341,3 @@ you normally don't even need to know these abstractions exist.
 But they'll be ready to help you once you conclude you need throttling.
 
 #### [Next: Part 3 &raquo;](./Part03.md) | [Tutorial Home](./README.md)
-