Noundry.Tuxedo

dotnet add package Noundry.Tuxedo
dotnet add package Microsoft.Data.SqlClient // or Npgsql, MySqlConnector, Microsoft.Data.Sqlite

using Noundry.Tuxedo.Contrib;

[Table("Products")]
public class Product
{
 [Key] // Auto-increment primary key
 public int Id { get; set; }

 public string Name { get; set; } = string.Empty;

 [Column("unit_price")] // Map to different column name
 public decimal Price { get; set; }

 [Computed] // Excluded from INSERT/UPDATE
 public DateTime CreatedAt { get; set; }
}

using Noundry.Tuxedo.DependencyInjection;

// SQL Server
services.AddTuxedoSqlServer("Server=.;Database=MyDb;Integrated Security=true;");

// PostgreSQL
services.AddTuxedoPostgres("Host=localhost;Database=mydb;Username=user;Password=pass;");

// MySQL
services.AddTuxedoMySql("Server=localhost;Database=mydb;Uid=user;Pwd=pass;");

// SQLite
services.AddTuxedoSqlite("mydb.sqlite");

// SQLite in-memory (for tests)
services.AddTuxedoSqliteInMemory("TestDb");

using Noundry.Tuxedo.Contrib;

public class ProductService
{
 private readonly IDbConnection _db;
 public ProductService(IDbConnection db) => _db = db;

 public async Task<Product?> GetByIdAsync(int id)
 => await _db.GetAsync<Product>(id);

 public async Task<IEnumerable<Product>> GetAllAsync()
 => await _db.GetAllAsync<Product>();

 public async Task<int> CreateAsync(Product product)
 => await _db.InsertAsync(product);

 public async Task<bool> UpdateAsync(Product product)
 => await _db.UpdateAsync(product);

 public async Task<bool> DeleteAsync(Product product)
 => await _db.DeleteAsync(product);
}

using Noundry.Tuxedo;

// Query multiple rows
var products = await _db.QueryAsync<Product>(
 "SELECT * FROM Products WHERE Price > @MinPrice",
 new { MinPrice = 10.00m });

// Query single or default
var product = await _db.QuerySingleOrDefaultAsync<Product>(
 "SELECT * FROM Products WHERE Id = @Id",
 new { Id = 1 });

// Execute non-query
int rows = await _db.ExecuteAsync(
 "UPDATE Products SET Price = @Price WHERE Id = @Id",
 new { Price = 19.99m, Id = 1 });

// Execute scalar
int count = await _db.ExecuteScalarAsync<int>(
 "SELECT COUNT(*) FROM Products WHERE Price > @MinPrice",
 new { MinPrice = 10.00m });

var order = _db.Query<Order, Customer, Order>(
 @"SELECT o.*, c.* FROM Orders o
 INNER JOIN Customers c ON o.CustomerId = c.Id
 WHERE o.Id = @OrderId",
 (order, customer) => { order.Customer = customer; return order; },
 new { OrderId = 1 },
 splitOn: "Id").FirstOrDefault();

using Noundry.Tuxedo.QueryBuilder;

// Basic query with filtering and ordering
var products = await new QueryBuilder<Product>(TuxedoDialect.SqlServer)
 .SelectAll()
 .Where(p => p.Price > 10 && p.IsActive)
 .OrderBy(p => p.Name)
 .ToListAsync(connection);

// Advanced filtering
var query = new QueryBuilder<Product>()
 .SelectAll()
 .Where(p => p.Price > 10)
 .And(p => p.IsActive == true)
 .WhereIn(p => p.CategoryId, new[] { 1, 2, 3 })
 .WhereBetween(p => p.Price, 10.00m, 50.00m)
 .WhereNull(p => p.DeletedAt);

// Joins
var orders = new QueryBuilder<Order>()
 .SelectAll()
 .InnerJoin<Customer>((o, c) => o.CustomerId == c.Id)
 .LeftJoin<OrderItem>((o, oi) => o.Id == oi.OrderId);

// Pagination
var page = new QueryBuilder<Product>()
 .SelectAll()
 .OrderBy(p => p.Name)
 .Page(pageIndex: 2, pageSize: 10);

// Aggregations
int total = await new QueryBuilder<Product>()
 .Count()
 .Where(p => p.IsActive)
 .CountAsync(connection);

using Noundry.Tuxedo.Pagination;

PagedResult<Product> result = await _db.QueryPagedAsync<Product>(
 "SELECT * FROM Products WHERE IsActive = 1 ORDER BY Name",
 pageIndex: 0, // Zero-based page index
 pageSize: 20, // Max 1,000 per page
 new { IsActive = true });

// Access results
List<Product> items = result.Items;
int totalCount = result.TotalCount;
int totalPages = result.TotalPages;
bool hasNext = result.HasNextPage;
bool hasPrev = result.HasPreviousPage;

using Noundry.Tuxedo.Patterns;

public class OrderService
{
 private readonly IDbConnection _connection;

 public async Task CreateOrderAsync(Order order, List<OrderItem> items)
 {
 using var uow = new UnitOfWork(_connection);
 await uow.BeginTransactionAsync();

 try
 {
 var orderRepo = uow.Repository<Order>();
 var itemRepo = uow.Repository<OrderItem>();

 var created = await orderRepo.AddAsync(order);
 foreach (var item in items)
 {
 item.OrderId = created.Id;
 await itemRepo.AddAsync(item);
 }

 await uow.CommitAsync();
 }
 catch
 {
 await uow.RollbackAsync();
 throw;
 }
 }
}

using Noundry.Tuxedo.Exceptions;

var db = connection.WithExceptionTranslation();

try
{
 await db.InsertAsync(product);
}
catch (UniqueConstraintException ex)
{
 // Duplicate key: ex.ConstraintName, ex.ConstraintProperties
}
catch (ReferenceConstraintException ex)
{
 // Foreign key violation: ex.ConstraintName
}
catch (CannotInsertNullException ex)
{
 // NULL not allowed: ex.ColumnName
}
catch (MaxLengthExceededException ex)
{
 // String too long: ex.ColumnName, ex.MaxLength
}

using Noundry.Tuxedo.Auditor;

var auditedDb = connection.WithAuditing(config =>
{
 config.UserProvider = new HttpContextAuditUserProvider(httpContextAccessor);
 config.DataProvider = new SqlServerAuditDataProvider(connection);
});

// All CRUD operations are now automatically audited
await auditedDb.InsertAsync(product); // Logs Insert event
await auditedDb.UpdateAsync(product); // Logs Update with old/new values
await auditedDb.DeleteAsync(product); // Logs Delete event