Implement state-aware database context execution overloads

Author: ivanvoyager

NuExt.System.Data.SQLite.slnx

@@ -4,6 +4,7 @@
     <File Path="Directory.Build.targets" />
     <File Path="README.md" />
   </Folder>
+  <Project Path="samples/MoviesAppSample/MoviesAppSample.csproj" />
   <Project Path="src/NuExt.System.Data.SQLite.csproj" />
   <Project Path="tests/NuExt.System.Data.SQLite.Tests.csproj" />
 </Solution>

src/NuExt.System.Data.SQLite.csproj

@@ -8,15 +8,15 @@
     <RootNamespace />
     <GenerateDocumentationFile>True</GenerateDocumentationFile>
     <NoWarn>$(NoWarn);1591;NETSDK1233</NoWarn>
-    <VersionPrefix>0.8.8</VersionPrefix>
+    <VersionPrefix>0.8.9</VersionPrefix>
   </PropertyGroup>
 
   <ItemGroup>
     <PackageReference Include="System.Data.SQLite.Core" Version="1.0.119" />
   </ItemGroup>
 
   <ItemGroup Condition="'$(NuExt_UseLocalProjects)' != 'true'">
-    <PackageReference Include="NuExt.System.Data" Version="0.8.7" />
+    <PackageReference Include="NuExt.System.Data" Version="0.8.8" />
   </ItemGroup>
 
   <ItemGroup Condition="'$(NuExt_UseLocalProjects)' == 'true'">

src/System/Data/SQLite/SQLiteDbContextExecutor.cs

@@ -114,4 +114,102 @@ public async ValueTask<T> ExecuteAsync<T>(Func<SQLiteDbContext, ValueTask<T>> fu
             }
         }, (Connection: connection, Func: func), cancellationToken).ConfigureAwait(false);
     }
+
+    /// <inheritdoc/>
+    public ValueTask ExecuteAsync<TState>(Action<SQLiteDbContext, TState> action, TState state, CancellationToken cancellationToken = default)
+    {
+        ArgumentNullException.ThrowIfNull(action);
+        cancellationToken.ThrowIfCancellationRequested();
+
+        using var connection = _createConnection();
+        connection.AcquireLock(static state =>
+        {
+            using var context = new SQLiteDbContext(state.Connection);
+            try
+            {
+                state.Action(context, state.State);
+                context.Commit();
+            }
+            catch (Exception ex)
+            {
+                context.TryRollback(ex);
+                throw;
+            }
+        }, (Connection: connection, Action: action, State: state), cancellationToken);
+
+        return default;
+    }
+
+    /// <inheritdoc/>
+    public async ValueTask ExecuteAsync<TState>(Func<SQLiteDbContext, TState, ValueTask> action, TState state, CancellationToken cancellationToken = default)
+    {
+        ArgumentNullException.ThrowIfNull(action);
+        cancellationToken.ThrowIfCancellationRequested();
+
+        using var connection = _createConnection();
+        await connection.AcquireLockAsync(static async state =>
+        {
+            using var context = new SQLiteDbContext(state.Connection);
+            try
+            {
+                await state.Action(context, state.State).ConfigureAwait(false);
+                context.Commit();
+            }
+            catch (Exception ex)
+            {
+                context.TryRollback(ex);
+                throw;
+            }
+        }, (Connection: connection, Action: action, State: state), cancellationToken).ConfigureAwait(false);
+    }
+
+    /// <inheritdoc/>
+    public ValueTask<T> ExecuteAsync<TState, T>(Func<SQLiteDbContext, TState, T> func, TState state, CancellationToken cancellationToken = default)
+    {
+        ArgumentNullException.ThrowIfNull(func);
+        cancellationToken.ThrowIfCancellationRequested();
+
+        using var connection = _createConnection();
+        T result = connection.AcquireLock(static state =>
+        {
+            using var context = new SQLiteDbContext(state.Connection);
+            try
+            {
+                T value = state.Func(context, state.State);
+                context.Commit();
+                return value;
+            }
+            catch (Exception ex)
+            {
+                context.TryRollback(ex);
+                throw;
+            }
+        }, (Connection: connection, Func: func, State: state), cancellationToken);
+
+        return new ValueTask<T>(result);
+    }
+
+    /// <inheritdoc/>
+    public async ValueTask<T> ExecuteAsync<TState, T>(Func<SQLiteDbContext, TState, ValueTask<T>> func, TState state, CancellationToken cancellationToken = default)
+    {
+        ArgumentNullException.ThrowIfNull(func);
+        cancellationToken.ThrowIfCancellationRequested();
+
+        using var connection = _createConnection();
+        return await connection.AcquireLockAsync(static async state =>
+        {
+            using var context = new SQLiteDbContext(state.Connection);
+            try
+            {
+                T result = await state.Func(context, state.State).ConfigureAwait(false);
+                context.Commit();
+                return result;
+            }
+            catch (Exception ex)
+            {
+                context.TryRollback(ex);
+                throw;
+            }
+        }, (Connection: connection, Func: func, State: state), cancellationToken).ConfigureAwait(false);
+    }
 }

src/System/Data/SQLite/SQLiteDbMigrationScope.cs

@@ -10,11 +10,11 @@ internal SQLiteDbMigrationScope(string name, SQLiteDbMigration[] migrations, str
         History = new SQLiteMigrationHistory(name);
     }
 
-    internal string Name { get; }
+    public string Name { get; }
 
     internal SQLiteDbMigration[] Migrations { get; }
 
-    internal string? Version { get; }
+    public string? Version { get; }
 
     internal SQLiteMigrationHistory History { get; }
 }