Add async lazy prop logic (kapi2289#13)

* add async logic to lazy prop

* convert to interface so that async lazy props can be added

* added support for async lazy props

* revert gitignore

* missed bin/ in gitignore

* update test to match example in readme

* update test to match example in readme

* fix a merge issue that overwrote defer prop checking

* overload signature to take sync or async callback method

* update readme

* reverted the order of the using statements. VS automatically alph ordered them, but there were no file changes

* Reformat code

---------

Co-authored-by: Chuck Waters <chuck.waters@reusser.com>
Co-authored-by: Kacper Ziubryniewicz <kacper@ziubryniewicz.pl>

Author: 3 people

InertiaCore/ResponseFactory.cs

@@ -22,6 +22,7 @@ internal interface IResponseFactory
     public void Share(string key, object? value);
     public void Share(IDictionary<string, object?> data);
     public LazyProp Lazy(Func<object?> callback);
+    public LazyProp Lazy(Func<Task<object?>> callback);
 }
 
 internal class ResponseFactory : IResponseFactory
@@ -118,5 +119,6 @@ public void Share(IDictionary<string, object?> data)
         context.Features.Set(sharedData);
     }
 
-    public LazyProp Lazy(Func<object?> callback) => new(callback);
+    public LazyProp Lazy(Func<object?> callback) => new LazyProp(callback);
+    public LazyProp Lazy(Func<Task<object?>> callback) => new LazyProp(callback);
 }

InertiaCore/Utils/LazyProp.cs

@@ -2,9 +2,10 @@ namespace InertiaCore.Utils;
 
 public class LazyProp
 {
-    private readonly Func<object?> _callback;
+    private readonly Func<Task<object?>> _callback;
 
-    public LazyProp(Func<object?> callback) => _callback = callback;
+    public LazyProp(Func<object?> callback) => _callback = async () => await Task.FromResult(callback());
+    public LazyProp(Func<Task<object?>> callback) => _callback = callback;
 
-    public object? Invoke() => _callback.Invoke();
+    public object? Invoke() => Task.Run(() => _callback.Invoke()).GetAwaiter().GetResult();
 }

InertiaCoreTests/UnitTestLazyData.cs

@@ -65,4 +65,75 @@ public void TestLazyPartialData()
             { "errors", new Dictionary<string, string>(0) }
         }));
     }
+
+
+    [Test]
+    [Description("Test if the lazy async data is fetched properly.")]
+    public void TestLazyAsyncData()
+    {
+        var testFunction = new Func<Task<object?>>(async () =>
+        {
+            Assert.Fail();
+            await Task.Delay(100);
+            return "Lazy Async";
+        });
+
+        var response = _factory.Render("Test/Page", new
+        {
+            Test = "Test",
+            TestFunc = new Func<string>(() => "Func"),
+            TestLazy = _factory.Lazy(testFunction)
+        });
+
+        var context = PrepareContext();
+
+        response.SetContext(context);
+        response.ProcessResponse();
+
+        var page = response.GetJson().Value as Page;
+
+        Assert.That(page?.Props, Is.EqualTo(new Dictionary<string, object?>
+        {
+            { "test", "Test" },
+            { "testFunc", "Func" },
+            { "errors", new Dictionary<string, string>(0) }
+        }));
+    }
+
+    [Test]
+    [Description("Test if the lazy async data is fetched properly with specified partial props.")]
+    public void TestLazyAsyncPartialData()
+    {
+        var testFunction = new Func<Task<string>>(async () =>
+        {
+            await Task.Delay(100);
+            return "Lazy Async";
+        });
+
+        var response = _factory.Render("Test/Page", new
+        {
+            TestFunc = new Func<string>(() => "Func"),
+            TestLazy = _factory.Lazy(async () => await testFunction())
+        });
+
+        var headers = new HeaderDictionary
+        {
+            { "X-Inertia-Partial-Data", "testFunc,testLazy" },
+            { "X-Inertia-Partial-Component", "Test/Page" }
+        };
+
+        var context = PrepareContext(headers);
+
+        response.SetContext(context);
+        response.ProcessResponse();
+
+        var page = response.GetJson().Value as Page;
+
+        Assert.That(page?.Props, Is.EqualTo(new Dictionary<string, object?>
+        {
+            { "testFunc", "Func" },
+            { "testLazy", "Lazy Async" },
+            { "errors", new Dictionary<string, string>(0) }
+        }));
+    }
 }

README.md

@@ -31,6 +31,7 @@ and its usage is more similar to the official adapters'.
   * [Backend](#backend)
 - [Features](#features)
   * [Shared data](#shared-data)
+  * [Async Lazy Props](#async-lazy-props)
   * [Server-side rendering](#server-side-rendering)
   * [Vite helper](#vite-helper)
     - [Examples](#examples-1)
@@ -165,6 +166,28 @@ app.Use(async (context, next) =>
 });
 ```
 
+### Async Lazy Props
+
+You can use async lazy props to load data asynchronously in your components. This is useful for loading data that is not needed for the initial render of the page.
+```csharp
+
+// simply use the LazyProps the same way you normally would, except pass in an async function
+
+    public async Task<IActionResult> Index()
+    {
+        var posts = new LazyProp(async () => await _context.Posts.ToListAsync());
+        
+        var data = new
+        {
+            Posts = posts,
+        };
+        
+        return Inertia.Render("Posts", data);
+    }
+
+
+```
+
 ### Server-side rendering
 
 If you want to enable SSR in your Inertia app, remember to add `Inertia.Head()` to your layout:
@@ -224,6 +247,7 @@ builder.Services.AddViteHelper(options =>
 });
 ```
 
+
 #### Examples
 ---