Refactor SQL execution classes into new namespace

Restructure and refactor classes related to SQL execution within the `EnvelopeGenerator.Infrastructure` namespace. Key changes include:
- Added `EnvelopeGenerator.Infrastructure.Executor` namespace.
- Moved and redefined `Query`, `QueryExtension`, `SQLExecutor`, `SQLExecutorBaseEntity`, and `SQLExecutorParams` classes to the new namespace.
- Maintained existing functionality while improving code organization and clarity.

EnvelopeGenerator.Infrastructure/Executor/Query.cs

@@ -0,0 +1,41 @@
+using EnvelopeGenerator.Application.Contracts.SQLExecutor;
+using Microsoft.EntityFrameworkCore;
+
+namespace EnvelopeGenerator.Infrastructure.Executor;
+
+public sealed record Query<TEntity> : IQuery<TEntity>
+{
+    private readonly IQueryable<TEntity> _query;
+
+    internal Query(IQueryable<TEntity> queryable)
+    {
+        _query = queryable;
+    }
+
+    public TEntity First() => _query.First();
+
+    public Task<TEntity> FirstAsync() => _query.FirstAsync();
+
+    public TEntity? FirstOrDefault() => _query.FirstOrDefault();
+
+
+    public Task<TEntity?> FirstOrDefaultAsync() => _query.FirstOrDefaultAsync();
+
+
+    public TEntity Single() => _query.Single();
+
+
+    public Task<TEntity> SingleAsync() => _query.SingleAsync();
+
+
+    public TEntity? SingleOrDefault() => _query.SingleOrDefault();
+
+
+    public Task<TEntity?> SingleOrDefaultAsync() => _query.SingleOrDefaultAsync();
+
+
+    public IEnumerable<TEntity> ToList() => _query.ToList();
+
+
+    public async Task<IEnumerable<TEntity>> ToListAsync() => await _query.ToListAsync();
+}

EnvelopeGenerator.Infrastructure/Executor/QueryExtension.cs

@@ -0,0 +1,9 @@
+namespace EnvelopeGenerator.Infrastructure.Executor;
+
+public static class QueryExtension
+{
+    public static Query<TEntity> ToQuery<TEntity>(this IQueryable<TEntity> queryable) where TEntity : class
+    {
+        return new Query<TEntity>(queryable);
+    }
+}

EnvelopeGenerator.Infrastructure/Executor/SQLExecutor.cs

@@ -0,0 +1,33 @@
+using Dapper;
+using EnvelopeGenerator.Application.Contracts.SQLExecutor;
+using Microsoft.Data.SqlClient;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Options;
+
+namespace EnvelopeGenerator.Infrastructure.Executor;
+
+public class SQLExecutor : ISQLExecutor
+{
+    private readonly SQLExecutorParams _params;
+
+    private readonly IServiceProvider _provider;
+
+    public SQLExecutor(IServiceProvider provider, IOptions<SQLExecutorParams> sqlExecutorParamsOptions)
+    {
+        _provider = provider;
+        _params = sqlExecutorParamsOptions.Value;
+    }
+
+    public async Task<IEnumerable<TEntity>> Execute<TEntity>(string sql, DynamicParameters parameters, CancellationToken cancellation = default)
+    {
+        using var connection = new SqlConnection(_params.ConnectionString);
+        await connection.OpenAsync(cancellation);
+        return await connection.QueryAsync<TEntity>(sql, parameters);
+    }
+
+    public Task<IEnumerable<TEntity>> Execute<TEntity, TSQL>(DynamicParameters parameters, CancellationToken cancellation = default) where TSQL : ISQL
+    {
+        var sql = _provider.GetRequiredService<TSQL>();
+        return Execute<TEntity>(sql.Raw, parameters, cancellation);
+    }
+}

EnvelopeGenerator.Infrastructure/Executor/SQLExecutorBaseEntity.cs

@@ -0,0 +1,31 @@
+using EnvelopeGenerator.Application.Contracts.SQLExecutor;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Options;
+
+namespace EnvelopeGenerator.Infrastructure.Executor;
+
+public sealed class SQLExecutor<T> : SQLExecutor, ISQLExecutor<T> where T : class
+{
+    private readonly EGDbContext _context;
+
+    private readonly IServiceProvider _provider;
+
+    public SQLExecutor(EGDbContext context, IServiceProvider provider, IOptions<SQLExecutorParams> options) : base(provider, options)
+    {
+        _context = context;
+        _provider = provider;
+    }
+
+    public IQuery<T> Execute(string sql, CancellationToken cancellation = default, params object[] parameters)
+        => _context
+            .Set<T>()
+            .FromSqlRaw(sql, parameters)
+            .ToQuery();
+
+    public IQuery<T> Execute<TSQL>(CancellationToken cancellation = default, params object[] parameters) where TSQL : ISQL<T>
+    {
+        var sql = _provider.GetRequiredService<TSQL>();
+        return Execute(sql.Raw);
+    }
+}

EnvelopeGenerator.Infrastructure/Executor/SQLExecutorParams.cs

@@ -0,0 +1,6 @@
+namespace EnvelopeGenerator.Infrastructure.Executor;
+
+public class SQLExecutorParams
+{
+    public string? ConnectionString { get; set; }
+}