Testing fixes

DragonSpark.Application/Entities/Editing/CommitAwareEditor.cs

@@ -40,6 +40,11 @@ public void Attach(object entity)
 		_previous.Attach(entity);
 	}
 
+	public void Detach(object entity)
+	{
+		_previous.Detach(entity);
+	}
+
 	public void Update(object entity)
 	{
 		_previous.Update(entity);

DragonSpark.Application/Entities/Editing/Edit.cs

@@ -51,6 +51,11 @@ public void Attach(object entity)
 		_editor.Attach(entity);
 	}
 
+	public void Detach(object entity)
+	{
+		_editor.Detach(entity);
+	}
+
 	public void Update(object entity)
 	{
 		_editor.Update(entity);

DragonSpark.Application/Entities/Editing/EditExisting.cs

@@ -1,7 +1,5 @@
 using DragonSpark.Compose;
-using DragonSpark.Model.Commands;
-using DragonSpark.Model.Operations;
-using System;
+using Microsoft.EntityFrameworkCore;
 using System.Threading.Tasks;
 
 namespace DragonSpark.Application.Entities.Editing;
@@ -21,7 +19,7 @@ public async ValueTask<Edit<T>> Get(T parameter)
 	{
 		var (context, disposable) = _scopes.Get();
 		var editor = new Editor(context, await disposable.Await());
-		editor.Attach(parameter);
+		context.ChangeTracker.TrackGraph(parameter, x => x.Entry.State = EntityState.Unchanged);
 		if (_reload)
 		{
 			await context.Entry(parameter).ReloadAsync().ConfigureAwait(false);
@@ -31,6 +29,7 @@ public async ValueTask<Edit<T>> Get(T parameter)
 	}
 }
 
+/*
 // TODO
 
 public class ModifyExisting<T> : IOperation<T>
@@ -60,4 +59,4 @@ public async ValueTask Get(T parameter)
 		await _modify.Await(edit);
 		await edit.Await();
 	}
-}
+}*/

DragonSpark.Application/Entities/Editing/Editor.cs

@@ -28,6 +28,11 @@ public void Attach(object entity)
 		_context.Attach(entity);
 	}
 
+	public void Detach(object entity)
+	{
+		_context.Entry(entity).State = EntityState.Detached;
+	}
+
 	public void Update(object entity)
 	{
 		_context.Update(entity);

DragonSpark.Application/Entities/Editing/IEditor.cs

@@ -10,6 +10,8 @@ public interface IEditor : IOperation, IDisposable
 
 	void Attach(object entity);
 
+	void Detach(object entity); // TODO: Remove
+
 	void Update(object entity);
 
 	void Remove(object entity);

DragonSpark.Application/Entities/Editing/ManyEdit.cs

@@ -36,6 +36,11 @@ public void Attach(object entity)
 		_editor.Attach(entity);
 	}
 
+	public void Detach(object entity)
+	{
+		_editor.Detach(entity);
+	}
+
 	public void Update(object entity)
 	{
 		_editor.Update(entity);

DragonSpark.Application/Entities/Editing/Modify.cs

@@ -1,6 +1,8 @@
 using DragonSpark.Application.Entities.Queries.Composition;
 using DragonSpark.Compose;
+using DragonSpark.Model.Commands;
 using DragonSpark.Model.Operations;
+using System;
 using System.Threading.Tasks;
 
 namespace DragonSpark.Application.Entities.Editing;
@@ -16,6 +18,15 @@ protected Modify(IScopes scopes, Await<Edit<T>> configure)
 
 	protected Modify(IEdit<T, T> edit, Await<Edit<T>> configure) : base(edit, configure) {}
 
+	protected Modify(IEdit<T> edit, ICommand<Edit<T>> modify) : base(edit, modify) {}
+
+	protected Modify(IEdit<T> edit, ICommand<T> modify) : base(edit, modify) {}
+
+	protected Modify(IEdit<T> edit, IOperation<T> modify) : base(edit, modify) {}
+
+	protected Modify(IEdit<T> edit, IOperation<Edit<T>> modify) : base(edit, modify) {}
+
+	protected Modify(IEdit<T> edit, Action<T> modify) : this(edit, Start.A.Command(modify).Get()) {}
 }
 
 public class Modify<TIn, T> : IOperation<TIn>
@@ -38,6 +49,13 @@ protected Modify(IEdit<TIn, T> select, Await<T> configure) : this(select, x => c
 
 	protected Modify(IEdit<TIn, T> select, IOperation<Edit<T>> configure) : this(select, configure.Await) {}
 
+	protected Modify(IEdit<TIn, T> edit, ICommand<Edit<T>> modify) : this(edit, modify.Then().Operation().Out()) {}
+
+	protected Modify(IEdit<TIn, T> edit, ICommand<T> modify)
+		: this(edit, Start.A.Selection<Edit<T>>().By.Calling(x => x.Subject).Terminate(modify).Operation().Out()) {}
+
+	protected Modify(IEdit<TIn, T> edit, Action<T> modify) : this(edit, Start.A.Command(modify).Get()) {}
+
 	protected Modify(IEdit<TIn, T> select, Await<Edit<T>> configure)
 	{
 		_select    = select;

DragonSpark.Application/Entities/Transactions/AssignAmbientComponentsTransaction.cs

@@ -0,0 +1,10 @@
+using Microsoft.EntityFrameworkCore;
+using System;
+
+namespace DragonSpark.Application.Entities.Transactions;
+
+sealed class AssignAmbientComponentsTransaction : AppendedTransaction
+{
+	public AssignAmbientComponentsTransaction(IServiceProvider first, DbContext second)
+		: base(new AssignAmbientProviderTransaction(first), new AssignAmbientEntityContextTransaction(second)) {}
+}

DragonSpark.Application/Entities/Transactions/AssignAmbientEntityContextTransaction.cs

@@ -0,0 +1,36 @@
+using DragonSpark.Model;
+using Microsoft.EntityFrameworkCore;
+using System;
+using System.Threading.Tasks;
+
+namespace DragonSpark.Application.Entities.Transactions;
+
+sealed class AssignAmbientEntityContextTransaction : StoreTransaction<DbContext>
+{
+	public AssignAmbientEntityContextTransaction(DbContext context) : base(context, LogicalContext.Default) {}
+}
+
+// TODO
+
+sealed class DisposingTransaction : ITransaction
+{
+	readonly IDisposable _disposable;
+
+	public DisposingTransaction(IDisposable disposable) => _disposable = disposable;
+
+	public async ValueTask DisposeAsync()
+	{
+		if (_disposable is IAsyncDisposable disposableAsyncDisposable)
+		{
+			await disposableAsyncDisposable.DisposeAsync().ConfigureAwait(false);
+		}
+		else
+		{
+			_disposable.Dispose();
+		}
+	}
+
+	public void Execute(None parameter) {}
+
+	public ValueTask Get() => ValueTask.CompletedTask;
+}

DragonSpark.Application/Entities/Transactions/AssignAmbientProviderTransaction.cs

@@ -0,0 +1,9 @@
+using DragonSpark.Composition.Scopes;
+using System;
+
+namespace DragonSpark.Application.Entities.Transactions;
+
+sealed class AssignAmbientProviderTransaction : StoreTransaction<IServiceProvider>
+{
+	public AssignAmbientProviderTransaction(IServiceProvider value) : base(value, LogicalProvider.Default) {}
+}

DragonSpark.Application/Entities/Transactions/DatabaseTransaction.cs

@@ -1,4 +1,5 @@
-using DragonSpark.Model;
+using DragonSpark.Compose;
+using DragonSpark.Model;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Infrastructure;
 using System.Threading.Tasks;
@@ -30,5 +31,31 @@ public async ValueTask Get()
 		}
 	}
 
+	public ValueTask DisposeAsync() => _facade.CurrentTransaction?.DisposeAsync() ?? ValueTask.CompletedTask;
+}
+
+// TODO
+
+public sealed class RequiredDatabaseTransaction : ITransaction
+{
+	readonly DbContext      _context;
+	readonly DatabaseFacade _facade;
+
+	public RequiredDatabaseTransaction(DbContext context) : this(context, context.Database) {}
+
+	public RequiredDatabaseTransaction(DbContext context, DatabaseFacade facade)
+	{
+		_context = context;
+		_facade  = facade;
+	}
+
+	public void Execute(None parameter) {}
+
+	public async ValueTask Get()
+	{
+		await _context.SaveChangesAsync().ConfigureAwait(false);
+		await _facade.CurrentTransaction.Verify().CommitAsync().ConfigureAwait(false);
+	}
+
 	public ValueTask DisposeAsync() => _facade.CurrentTransaction?.DisposeAsync() ?? ValueTask.CompletedTask;
 }

DragonSpark.Application/Entities/Transactions/DatabaseTransactions.cs

@@ -0,0 +1,47 @@
+using DragonSpark.Compose;
+using DragonSpark.Model.Results;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using System.Threading.Tasks;
+
+namespace DragonSpark.Application.Entities.Transactions;
+
+public sealed class DatabaseTransactions : ITransactions
+{
+	readonly DbContext      _context;
+	readonly DatabaseFacade _facade;
+
+	public DatabaseTransactions(DbContext owner) : this(owner, owner.Database) {}
+
+	public DatabaseTransactions(DbContext context, DatabaseFacade facade)
+	{
+		_context = context;
+		_facade  = facade;
+	}
+
+	public async ValueTask<ITransaction> Get()
+	{
+		await _facade.BeginTransactionAsync().ConfigureAwait(false);
+		return new DatabaseTransaction(_context);
+	}
+}
+
+// TODO
+
+public sealed class LogicalDatabaseTransactions : ITransactions
+{
+	public static LogicalDatabaseTransactions Default { get; } = new();
+
+	LogicalDatabaseTransactions() : this(LogicalContext.Default) {}
+
+	readonly IResult<DbContext?> _context;
+
+	public LogicalDatabaseTransactions(IResult<DbContext?> context) => _context = context;
+
+	public async ValueTask<ITransaction> Get()
+	{
+		var context = _context.Get().Verify();
+		await context.Database.BeginTransactionAsync().ConfigureAwait(false);
+		return new RequiredDatabaseTransaction(context);
+	}
+}

DragonSpark.Application/Entities/Transactions/EntityContextTransactions.cs

@@ -7,16 +7,33 @@ namespace DragonSpark.Application.Entities.Transactions;
 
 public sealed class EntityContextTransactions : ITransactions
 {
-	readonly IScopedTransactions _boundaries;
+	readonly IServiceScopedTransactions _previous;
 
-	public EntityContextTransactions(IScopedTransactions boundaries) => _boundaries = boundaries;
+	public EntityContextTransactions(IServiceScopedTransactions previous) => _previous = previous;
 
 	public ValueTask<ITransaction> Get()
 	{
-		var previous = _boundaries.Get();
+		var previous = _previous.Get();
 		var context  = previous.Provider.GetRequiredService<DbContext>();
 		var second   = new EntityContextTransaction(context);
 		var result   = new AppendedTransaction(previous, second).ToOperation<ITransaction>();
 		return result;
 	}
+}
+
+// TODO
+
+public sealed class StandardEntityContextTransactions : ITransactions
+{
+	readonly IServiceScopedTransactions _previous;
+
+	public StandardEntityContextTransactions(IServiceScopedTransactions previous) => _previous = previous;
+
+	public ValueTask<ITransaction> Get()
+	{
+		var previous = _previous.Get();
+		var context  = previous.Provider.GetRequiredService<DbContext>();
+		var appended = new AppendedTransaction(previous, new AssignAmbientEntityContextTransaction(context));
+		return appended.ToOperation<ITransaction>();
+	}
 }

DragonSpark.Application/Entities/Transactions/EstablishSessionTransactions.cs

@@ -2,6 +2,6 @@
 
 public sealed class EstablishSessionTransactions : AppendedTransactions
 {
-	public EstablishSessionTransactions(SessionBoundaryTransactions first, SessionDatabaseTransactions second)
+	public EstablishSessionTransactions(SessionBoundaryTransactions first, DatabaseTransactions second)
 		: base(first, second) {}
 }

DragonSpark.Application/Entities/Transactions/IScopedTransactions.cs → DragonSpark.Application/Entities/Transactions/IServiceScopedTransactions.cs

@@ -2,4 +2,4 @@
 
 namespace DragonSpark.Application.Entities.Transactions;
 
-public interface IScopedTransactions : IResult<IScopedTransaction>;
+public interface IServiceScopedTransactions : IResult<IScopedTransaction>;