Nosabit.Adapters.Persistence.SqlServer.RepositoryPattern.Abstractions 1.2.3

Nosabit.Adapters.Persistence.SqlServer.RepositoryPattern.Abstractions

Biblioteca de abstracciones para implementar el patrón Repository con SQL Server en aplicaciones .NET. Define una interfaz genérica que facilita las operaciones CRUD y consultas complejas para entidades de dominio.

Instalación

Package Manager

Install-Package Nosabit.Adapters.Persistence.SqlServer.RepositoryPattern.Abstractions

.NET CLI

dotnet add package Nosabit.Adapters.Persistence.SqlServer.RepositoryPattern.Abstractions

Características principales

• Patrón Repository genérico: Define una interfaz IRepo<TEntity> para operaciones de base de datos
• Operaciones CRUD completas: Métodos para crear, leer, actualizar y eliminar entidades
• Mapeo de entidades: Soporte para mapeo automático y personalizado de resultados de consultas
• Consultas con DTO: Funciones para obtener resultados como DTOs personalizados
• Soporte para múltiples tipos: Permite mapear consultas con múltiples tipos de entidades
• Flexibilidad en procedimientos almacenados: Permite especificar nombres de SP personalizados
• Control de parámetros: Manejo avanzado de parámetros dinámicos para consultas
• Soporte para esquemas: Permite organizar procedimientos por esquemas de base de datos
• Configuración de tiempos de espera: Control fino de timeouts para operaciones de larga duración

Interfaz principal

La biblioteca define la interfaz genérica IRepo<TEntity> que sirve como base para implementar el patrón Repository:

public interface IRepo<TEntity> where TEntity : class
{
    // Métodos básicos para obtener entidades
    Task<IEnumerable<TEntity>> Obtener(object? Param = null, bool RemoveUnused = true, Enum? connId = null, int? Timeout = null, string? Sp = null);
    Task<TEntity?> ObtenerById(object? Param = null, bool RemoveUnused = true, Enum? connId = null, int? Timeout = null, string? Sp = null);
    
    // Métodos para operaciones CUD (Create, Update, Delete)
    Task<DBEntity> Guardar(object? Param = null, bool RemoveUnused = true, Enum? connId = null, int? Timeout = null, string? Sp = null);
    Task<DBLastInsertEntity<TId>> GuardarAndGetId<TId>(object? Param = null, bool RemoveUnused = true, Enum? connId = null, int? Timeout = null, string? Sp = null);
    Task<DBEntity> Eliminar(object? Param = null, bool RemoveUnused = true, Enum? connId = null, int? Timeout = null, string? Sp = null);
    Task<DBEntity> EliminarByIdMultiple(object? id = null, string? StartPrefix = null, string? EndPrefix = null, Enum? connId = null, int? Timeout = null, string? Sp = null);
    
    // Métodos para obtener DTOs
    Task<IEnumerable<TDto>> ObtenerDto<TDto>(object? Param = null, bool RemoveUnused = true, Enum? connId = null, int? Timeout = null, string? Sp = null);
    Task<Dto?> ObtenerDtoById<Dto>(object? Param = null, bool RemoveUnused = true, Enum? connId = null, int? Timeout = null, string? Sp = null);
    
    // Métodos para combos (select/dropdown)
    Task<IEnumerable<SelectItemDto>> ObtenerCbo(object? Param = null, bool RemoveUnused = true, Enum? connId = null, int? Timeout = null, string? Sp = null);
    Task<IEnumerable<ReactSelectItemDto>> ObtenerRCbo(object? Param = null, bool RemoveUnused = true, Enum? connId = null, int? Timeout = null, string? Sp = null);
    
    // Múltiples sobrecargas adicionales para mapeo, parámetros personalizados, etc.
    // (Ver documentación completa de la interfaz para más detalles)
    
    // Utilidad para manejar parámetros dinámicos
    DynamicParameters? UseParamerter(object? parameters);
}

Uso de las abstracciones

Este paquete contiene solo las interfaces y no las implementaciones. La implementación correspondiente se realiza a través del paquete complementario que proporciona métodos de extensión para el registro de dependencias.

Registro en el contenedor de IoC

Utilizando los métodos de extensión proporcionados por el paquete de implementación:

// En Program.cs o Startup.cs
public void ConfigureServices(IServiceCollection services)
{
    // Registrar repositorios por tipo y esquema
    services.AddRepositoryScope<ProductoEntity>(EsquemaDB.Inventario);
    services.AddRepositoryScope<CategoriaEntity>(EsquemaDB.Catalogo);
    services.AddRepositoryScope<ClienteEntity>(EsquemaDB.Ventas);
    
    // También se puede registrar como singleton si es necesario
    services.AddRepositorySingleton<ConfiguracionEntity>();
}

Uso en servicios

Una vez registrados, puedes inyectar los repositorios directamente en tus servicios:

public class ProductoService
{
    private readonly IRepo<ProductoEntity> _productoRepo;
    
    public ProductoService(IRepo<ProductoEntity> productoRepo)
    {
        _productoRepo = productoRepo;
    }
    
    public async Task<IEnumerable<ProductoDto>> ObtenerProductosActivos()
    {
        return await _productoRepo.ObtenerDto<ProductoDto>(
            new { Activo = true }
        );
    }
    
    public async Task<DBEntity> GuardarProducto(ProductoEntity producto)
    {
        return await _productoRepo.Guardar(producto);
    }
}

Patrones de uso común

Operaciones CRUD básicas

// Obtener todos los registros
var productos = await _productoRepo.Obtener();

// Obtener por ID
var producto = await _productoRepo.ObtenerById(new { Id = 123 });

// Guardar (insertar o actualizar)
var result = await _productoRepo.Guardar(productoEntity);

// Eliminar
var result = await _productoRepo.Eliminar(new { Id = 123 });

Trabajar con DTOs

// Obtener como DTO
var productosDto = await _productoRepo.ObtenerDto<ProductoDto>();

// Obtener DTO por ID
var productoDto = await _productoRepo.ObtenerDtoById<ProductoDto>(new { Id = 123 });

Trabajar con procedimientos almacenados específicos

// Especificar nombre de procedimiento almacenado
var resultado = await _productoRepo.Obtener(
    new { Activo = true },
    Sp: "ObtenerProductosActivos"
);

// Especificar timeout para operaciones largas
var reporteComplejo = await _productoRepo.ObtenerDto<ReporteDto>(
    Param: new { FechaInicio = fechaInicio, FechaFin = fechaFin },
    Timeout: 120, // 120 segundos
    Sp: "GenerarReporteVentas"
);

Mapeo de múltiples entidades

// Obtener entidad principal con entidades relacionadas mapeadas automáticamente
var productoConDetalles = await _productoRepo.ObtenerById<DetalleEntity, ProveedorEntity>(
    "Id,DetalleId,ProveedorId", // Campos para hacer split
    new { Id = 123 }
);

// Mapeo personalizado
var productosMapeados = await _productoRepo.MapObtener<CategoriaEntity>(
    (producto, categoria) => {
        producto.NombreCategoria = categoria.Nombre;
        return producto;
    },
    "CategoriaId",
    new { Activo = true }
);

Obteniendo datos para combos/dropdowns

// Para select estándar
var opcionesSelect = await _categoriaRepo.ObtenerCbo();

// Para React Select
var opcionesReactSelect = await _categoriaRepo.ObtenerRCbo();

Convenciones para procedimientos almacenados

La interfaz asume ciertas convenciones para nombres de procedimientos almacenados:

• {Esquema}.{Entidad}Obtener: Para listar entidades
• {Esquema}.{Entidad}ObtenerById: Para obtener una entidad por ID
• {Esquema}.{Entidad}Guardar: Para crear o actualizar entidades
• {Esquema}.{Entidad}Eliminar: Para eliminar entidades
• {Esquema}.{Entidad}ObtenerCbo: Para obtener datos formateados para combos
• {Esquema}.{Entidad}ObtenerRCbo: Para obtener datos formateados para React Select

Donde:

• {Esquema}: Es el esquema de la base de datos (por defecto "dbo")
• {Entidad}: Es el nombre de la entidad (derivado automáticamente del tipo genérico TEntity)

Estas convenciones pueden modificarse mediante el parámetro Sp en cada método.

Implementación

El paquete complementario Nosabit.Adapters.Persistence.SqlServer.RepositoryPattern proporciona:

1. Implementación completa de la interfaz IRepo<TEntity>
2. Métodos de extensión para simplificar el registro de dependencias:

public static class RepoDependecyInjection
{
    // Registra el repositorio como Singleton (para datos que rara vez cambian)
    public static IServiceCollection AddRepositorySingleton<TEntity>(this IServiceCollection Service)
    {
        return Service;
    }
    
    // Registra el repositorio como Scoped con esquema específico
    public static IServiceCollection AddRepositoryScope<TEntity>(
        this IServiceCollection Service, 
        Enum Schema
    ) where TEntity : class
    {
        Service.AddScoped<IRepo<TEntity>>(sp => 
            new Repo<TEntity>(sp.GetRequiredService<ISqlDataAccess>(), Schema));
        return Service;
    }
}

Beneficios de utilizar estas abstracciones

• Separación de responsabilidades: Desacopla la lógica de acceso a datos de la lógica de negocio
• Código DRY: Evita repetir código para operaciones comunes en cada repositorio
• Flexibilidad: Proporciona múltiples sobrecargas para adaptarse a diferentes escenarios
• Testabilidad: Facilita la creación de mocks para pruebas unitarias
• Mantenibilidad: Permite cambiar la implementación sin afectar a los consumidores

Integración con otros paquetes Nosabit

Este paquete de abstracciones está diseñado para trabajar con otros paquetes de la familia Nosabit:

• Nosabit.Core: Proporciona tipos como DBEntity y extensiones de utilidad
• Nosabit.DataAccess.SqlServer.Abstractions: Define la interfaz ISqlDataAccess utilizada por el repositorio
• Nosabit.Adapters.Persistence.SqlServer.RepositoryPattern: Implementación concreta con métodos de extensión para el registro de dependencias

Requisitos

• .NET 6.0 o superior
• Dapper (para la implementación)

Licencia

Este proyecto está licenciado bajo la Licencia MIT.