DataAccessAwsSql.Data.Sql 1.0.8

Pacote nuget para facilitar conexões seguras com SQL Server utilizando ISecretCache e Settings, com suporte a Dapper e Entity Framework.

Para consumir DataAccessAwsSql.Data.Sql 👋

Criar um arquivo "appsettings.json" no projeto

{
  "Region": "sa-east-1",
  "SecretsManager": {
    "PortNumber": 1433,
    "HostName": "localhost",
    "DataBase": "LambdaJson",
    "UsersSecretName": "xxxxx",
    "PwdSecretName": "xxxx",
    "Environment" :  "Local"
  }
}

Model Settings 👋

public class Settings
{
    public int Port { get; set; }
    public string HostName { get; set; }
    public string DataBase { get; set; }
    public string UsersSecretName { get; set; }
    public string PwdSecretName { get; set; }
    public string Environment { get; set; } = "local";
}

Na sua Startup.cs ou no Program.cs, registre as dependências: 👋

builder.Services.Configure<Settings>(builder.Configuration.GetSection("SecretsManager"));
builder.Services.AddScoped<IDbSqlConnection, DbSqlConnection>();
builder.Services.AddSingleton<IAmazonSecretsManager, AmazonSecretsManagerClient>();
builder.Services.AddSingleton<ICredentialProvider, LocalCredentialProvider>();
builder.Services.AddScoped<IUnitOfWork, UnitOfWork>();
builder.Services.AddSingleton<ISecretCache, SecretManagerFacade>();

builder.Services.AddScoped<IUsersServico, UsersServico>();

Usar em uma aplicação MVC com Dapper 👋

 public class UsersServico : IUsersServico
    {
        private readonly IUnitOfWork _unitOfWork;

        public UsersServico(IUnitOfWork unitOfWork)
        {
            _unitOfWork = unitOfWork;
        }

        public async Task<List<Users>> ListaUsuario()
        {
            await _unitOfWork.InitializeAsync();

            List<Users> items = null;

            try
            {
                _unitOfWork.BeginTransaction();

                var itemSql = "SELECT * FROM Users";

                items = (await _unitOfWork.Connection.QueryAsync<Users>(
                    itemSql,
                    transaction: _unitOfWork.Transaction
                )).ToList();

                _unitOfWork.CommitTransaction();
            }
            catch
            {
                _unitOfWork.Rollback();
                throw;
            }
            finally
            {
                await _unitOfWork.DisposeAsync();
            }

            return items;
        }
    }

    public class UsersController : Controller
    {
        private readonly IUsersServico _usersServico;
        public UsersController(IUsersServico usersServico, IServiceScopeFactory serviceScopeFactory)
        {
            _usersServico = usersServico;
           
        }
        public async Task<IActionResult> Index()
        {
            var usuarios = await _usersServico.ListaUsuario();
            return View(usuarios);
        }
    }

Consumir na lambda : 👋

public class DependencyInjection
{
    internal static IServiceProvider ResolveDependencies()
    {
        var configuration = new ConfigurationBuilder()
            .SetBasePath(Directory.GetCurrentDirectory())
            .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
            .Build();

        var services = new ServiceCollection();

        services.Configure<Settings>(opt =>
        {
            opt.Port = int.Parse(configuration["SecretsManager:PortNumber"]);
            opt.DataBase = configuration["SecretsManager:DataBase"];
            opt.HostName = configuration["SecretsManager:HostName"];
            opt.UsersSecretName = configuration["SecretsManager:Username"];
            opt.PwdSecretName = configuration["SecretsManager:Password"];
            opt.Environment = configuration["SecretsManager:Environment"] ?? "local";
        });

        builder.Services.AddSingleton<IDbSqlConnection, DbSqlConnection>();
        builder.Services.AddSingleton<IAmazonSecretsManager, AmazonSecretsManagerClient>();
        builder.Services.AddSingleton<ICredentialProvider, LocalCredentialProvider>();
        builder.Services.AddScoped<IUnitOfWork, UnitOfWork>();
        builder.Services.AddSingleton<ISecretCache, SecretManagerFacade>();

        return services.BuildServiceProvider();
    }
}

Chamar na lambda : 👋

private readonly IServiceProvider _serviceProvider;

public Function()
{
   _serviceProvider = DependencyInjection.ResolveDependencies();
}

Usar em uma aplicação MVC com Entity Framework (EF) 👋

Na sua Startup.cs ou no Program.cs, registre as dependências: 👋

builder.Services.AddDbContext<ApplicationDbContext>(async (provider, options) =>
{
    var connProvider = provider.GetRequiredService<IConnectionStringProviderEF>();
    var connectionString = await connProvider.GetConnectionStringEFAsync();
    options.UseSqlServer(connectionString);
});
builder.Services.AddScoped<IConnectionStringProviderEF, SqlConnectionStringProviderEF>();

Usar em uma aplicação MVC com com Entity Framework (EF) 👋

Registrar as dependências no Program.cs ou Startup.cs:
builder.Services.AddScoped<IUsersEFServico, UsersEFServico>();

 public class UsersEFServico : IUsersEFServico
    {
        private readonly ApplicationDbContext _context;
        public UsersEFServico(ApplicationDbContext context)
        {
            _context = context;
        }
        public async Task<List<Users>> ListaUsuario()
        {
            return await _context.Users.ToListAsync();
        }
    }

    public class UsersEFController : Controller
    {
        private readonly IUsersEFServico _usersEFServico;

        public UsersEFController(IUsersEFServico usersEFServico)
        {
            _usersEFServico = usersEFServico;
        }

        public async Task<IActionResult> Index()
        {
            try
            {
                var users = await _usersEFServico.ListaUsuario();
                return View(users);
            }
            catch (Exception ex)
            {
                return View("Error", new { message = ex.Message });
            }
        }
    }

Análise Completa do Projeto 👋

1. Princípios SOLID — Aplicação correta:

| Classe/Interface                                                     | Princípio SOLID Aplicado              | Justificativa                                                                                                                           |
| -------------------------------------------------------------------- | ------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------- |
| **Settings**                                                         | SRP (Single Responsibility Principle) | Classe simples que encapsula apenas a configuração de conexão.                                                                          |
| **ICredentialProvider, IDbSqlConnection, ISecretCache, IUnitOfWork** | ISP (Interface Segregation Principle) | Interfaces coesas, com métodos específicos e de única responsabilidade.                                                                 |
| **DbSqlConnection**                                                  | SRP + DIP + OCP                       | Única responsabilidade (criar conexão), depende de abstrações, facilmente extensível via novas implementações de `ICredentialProvider`. |
| **LocalCredentialProvider**                                          | SRP + DIP                             | Fornece credenciais locais, isolada e testável.                                                                                         |
| **SecretCacheCredentialProviderFacade**                              | SRP + DIP + OCP                       | Isola a lógica de credenciais via secret cache, depende de abstração `ISecretCache`.                                                    |
| **SecretManagerFacade**                                              | SRP + DIP                             | Implementa `ISecretCache`, única responsabilidade: abstrair cache do AWS Secrets Manager.                                               |
| **UnitOfWork**                                                       | SRP + DIP                             | Única responsabilidade: gerenciar transações. Depende da abstração `IDbSqlConnection`.                                                  |

2. Clean Code — Boas práticas: 👋

 - Nomes claros e objetivos.
 - Tratamento de exceções apropriado.
 - Injeção de dependências aplicada.
 - Uso correto de IOptions<Settings>.
 - Classes pequenas e coesas.

3. Design Patterns utilizados: 👋

| Classe/Interface                         | Padrão Aplicado            | Justificativa                                                                                                    |
| ---------------------------------------- | -------------------------- | ---------------------------------------------------------------------------------------------------------------- |
| **ICredentialProvider e implementações** | Strategy                   | Diferentes formas de obter credenciais (`LocalCredentialProvider` ou via `SecretCacheCredentialProviderFacade`). |
| **SecretManagerFacade**                  | Facade                     | Simplifica a interação com o `SecretsManagerCache`.                                                              |
| **IUnitOfWork / UnitOfWork**             | Unit of Work               | Gerencia transações de forma consistente.                                                                        |
| **ISecretCache e SecretManagerFacade**   | Adapter                    | Adapta `SecretsManagerCache` para uma interface mais simples e isolada (`ISecretCache`).                         |
| **IDbSqlConnection e DbSqlConnection**   | Factory Method (implícito) | Método `GetSqlConnectionAsync` encapsula a criação da `SqlConnection`.                                           |

1. Princípios SOLID: 👋

S - Single Responsibility Principle (SRP) - Princípio da Responsabilidade Única

✔️ Todas as classes possuem uma responsabilidade única:

 - Settings → apenas carrega configurações.
 - DbSqlConnection → apenas cria conexões SQL.
 - UnitOfWork → apenas gerencia transações.
 - SecretManagerFacade → apenas lida com o cache de segredos.
 - SecretCacheCredentialProviderFacade → apenas recupera credenciais via ISecretCache.
 - LocalCredentialProvider → fornece credenciais no ambiente local.

O - Open/Closed Principle (OCP) - Aberto para Extensão, Fechado para Modificação

✔️ As classes seguem bem esse princípio, pois:

 - Dependem de abstrações (interfaces) e podem ser estendidas.
 - Por exemplo: ICredentialProvider tem duas implementações diferentes (Local e Facade).

L - Liskov Substitution Principle (LSP) - Princípio da Substituição de Liskov

✔️ Todas as implementações de interfaces podem ser substituídas sem quebrar o sistema.

 - Ex.: LocalCredentialProvider e SecretCacheCredentialProviderFacade.

I - Interface Segregation Principle (ISP) - Princípio da Segregação de Interface

✔️ As interfaces são coesas e não obrigam implementações a dependerem de métodos que não usam.

D - Dependency Inversion Principle (DIP) - Princípio da Inversão de Dependência

✔️ O código depende de abstrações (interfaces) e não de classes concretas.
✔️ Todas as dependências são injetadas via construtor (injeção de dependência).

Design Patterns (Padrões de Projeto)

| Padrão                             | Onde está aplicado                                                                                |
| ---------------------------------- | ------------------------------------------------------------------------------------------------- |
| **Facade**                         | SecretManagerFacade encapsula a lógica de acesso ao SecretsManager.                               |
| **Adapter**                        | SecretCacheCredentialProviderFacade atua como adaptador entre ISecretCache e ICredentialProvider. |
| **Factory Method (indiretamente)** | via DI, as implementações concretas são resolvidas automaticamente.                               |
| **Dependency Injection**           | via `builder.Services`.                                                                           |
| **Unit of Work**                   | Classe UnitOfWork gerencia transações de banco de dados.                                          |
 
### ✅ Padrões aplicados de forma correta e eficiente.

Estrutura de Pastas

| Pasta          | Conteúdo                                                                              | Correção                                       |
| -------------- | ------------------------------------------------------------------------------------- | ---------------------------------------------- |
| **Models**     | Settings                                                                              | ✅ Correto, são modelos de dados.               |
| **Facades**    | SecretManagerFacade, SecretCacheCredentialProviderFacade                              | ✅ Correto, classes que encapsulam subsistemas. |
| **Interfaces** | Todas as interfaces: ICredentialProvider, IDbSqlConnection, ISecretCache, IUnitOfWork | ✅ Correto, promove separação e organização.    |
| **Services**   | DbSqlConnection, LocalCredentialProvider, UnitOfWork                                  | ✅ Correto, são serviços de infraestrutura.     |
 
 ### ✅ Estrutura de pastas muito bem organizada e aderente a boas práticas.

⚖️ Licença

Este projeto é distribuído sob a licença MIT.

🙌 Contribuições

Contribuições são bem-vindas! Sinta-se à vontade para abrir Issues ou enviar Pull Requests.

👤 Autor

Desenvolvido por [Marcelo P. Matos].