Product.cs              ← згенерований (перезаписується при --force)
Product.Extensions.cs   ← ваш розширення (НІКОЛИ не перезаписується)

Infrastructure/
├── Entities/                         ← Згенеровані (перезаписуються при re-scaffold)
│   ├── Product.cs                    ← auto-generated
│   ├── Category.cs                   ← auto-generated
│   └── Order.cs                      ← auto-generated
├── Entities/Extensions/              ← Ваші розширення (НІКОЛИ не чіпати при scaffold)
│   ├── Product.Extensions.cs         ← бізнес-логіка Product
│   ├── Category.Extensions.cs        ← бізнес-логіка Category
│   └── Order.Extensions.cs           ← бізнес-логіка Order
└── ShopDbContext.cs                  ← згенерований
└── ShopDbContextExtensions.cs        ← ваші розширення DbContext

// Infrastructure/Entities/Extensions/Product.Extensions.cs
// Цей файл НІКОЛИ не перезаписується scaffold

namespace YourApp.Infrastructure.Entities;

// Той самий namespace і тип що у згенерованому Product.cs
public partial class Product
{
    // 1. Обчислювані властивості (computed properties)
    public decimal FinalPrice =>
        Discount.HasValue
            ? Price - (Price * Discount.Value / 100)
            : Price;

    public bool IsDiscounted => Discount.HasValue && Discount.Value > 0;

    // 2. Доменна логіка (методи)
    public void ApplyDiscount(decimal discountPercent)
    {
        if (discountPercent < 0 || discountPercent > 100)
            throw new ArgumentOutOfRangeException(nameof(discountPercent),
                "Discount must be between 0 and 100.");

        Discount = discountPercent;
    }

    public void Activate()  => IsActive = true;
    public void Deactivate() => IsActive = false;

    // 3. Форматування і відображення
    public string DisplayName => $"{Name} ({Category?.Name ?? "Uncategorized"})";

    // 4. Валідація (може бути використана у тестах і бізнес-логіці)
    public IReadOnlyList<string> Validate()
    {
        var errors = new List<string>();

        if (string.IsNullOrWhiteSpace(Name))
            errors.Add("Name is required.");

        if (Price <= 0)
            errors.Add("Price must be positive.");

        if (CategoryId <= 0)
            errors.Add("Category is required.");

        return errors;
    }

    // 5. Override ToString для кращого відлагодження
    public override string ToString() =>
        $"Product[{Id}]: {Name} @ {Price:C} (Active: {IsActive})";
}

// Infrastructure/ShopDbContextExtensions.cs
namespace YourApp.Infrastructure;

public partial class ShopDbContext
{
    // Зручні методи запитів
    public IQueryable<Product> ActiveProducts =>
        Set<Product>().Where(p => p.IsActive);

    public IQueryable<Product> ProductsByCategory(int categoryId) =>
        Set<Product>().Where(p => p.CategoryId == categoryId && p.IsActive);

    // Методи для складних операцій
    public async Task<int> SoftDeleteProductAsync(int productId)
    {
        return await Set<Product>()
            .Where(p => p.Id == productId)
            .ExecuteUpdateAsync(s => s.SetProperty(p => p.IsActive, false));
    }

    // Кастомні події (аудит, доменні події)
    public override async Task<int> SaveChangesAsync(CancellationToken ct = default)
    {
        // Автоматично встановити UpdatedAt для Modified entities
        var modifiedEntries = ChangeTracker.Entries<IHasTimestamps>()
            .Where(e => e.State == EntityState.Modified);

        foreach (var entry in modifiedEntries)
            entry.Entity.UpdatedAt = DateTime.UtcNow;

        return await base.SaveChangesAsync(ct);
    }
}

// Core/Interfaces/IAuditableEntity.cs
public interface IAuditableEntity
{
    DateTime CreatedAt { get; set; }
    DateTime? UpdatedAt { get; set; }
}

// Infrastructure/Entities/Extensions/Product.Extensions.cs
public partial class Product : IAuditableEntity, ISoftDeletable
{
    // Product вже має CreatedAt і UpdatedAt (від scaffold)
    // Тепер вони виконують контракт IAuditableEntity

    // ISoftDeletable: реалізація через IsActive поле
    bool ISoftDeletable.IsDeleted => !IsActive;
    void ISoftDeletable.SoftDelete() => IsActive = false;
    void ISoftDeletable.Restore()    => IsActive = true;
}

// Global Query Filter у DbContext extensions:
public partial class ShopDbContext
{
    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        // Викликаємо базовий OnModelCreating (згенерований)
        base.OnModelCreating(modelBuilder);

        // Додаємо Global Query Filter для soft delete
        foreach (var entityType in modelBuilder.Model.GetEntityTypes())
        {
            if (typeof(ISoftDeletable).IsAssignableFrom(entityType.ClrType))
            {
                var method = typeof(ShopDbContextExtensions)
                    .GetMethod(nameof(AddSoftDeleteFilter))!
                    .MakeGenericMethod(entityType.ClrType);

                method.Invoke(null, [modelBuilder]);
            }
        }
    }

    private static void AddSoftDeleteFilter<T>(ModelBuilder builder)
        where T : class, ISoftDeletable
    {
        builder.Entity<T>().HasQueryFilter(e => !e.IsDeleted);
    }
}

# --force: перезаписати наявні ЗГЕНЕРОВАНІ файли
dotnet ef dbcontext scaffold \
    "Name=ConnectionStrings:DefaultConnection" \
    Microsoft.EntityFrameworkCore.SqlServer \
    --output-dir Infrastructure/Entities \
    --context-dir Infrastructure \
    --context ShopDbContext \
    --no-onconfiguring \
    --force   # ← ключовий флаг: перезаписати

Infrastructure/
├── Generated/           ← Тут живуть автогенеровані файли
│   ├── Entities/        ← --output-dir Infrastructure/Generated/Entities
│   │   ├── Product.cs
│   │   ├── Category.cs
│   │   └── ...
│   └── ShopDbContext.cs ← --context-dir Infrastructure/Generated
└── Extensions/          ← Тут живуть ваші розширення (НЕ торкається --force)
    ├── Product.Extensions.cs
    ├── Category.Extensions.cs
    └── ShopDbContextExtensions.cs

#!/bin/bash
# scripts/rescaffold.sh

set -e  # зупинити при помилці

echo "🔄 Starting re-scaffold..."

# Параметри
CONNECTION="Name=ConnectionStrings:DefaultConnection"
PROVIDER="Microsoft.EntityFrameworkCore.SqlServer"
PROJECT="src/Infrastructure"
STARTUP="src/Api"

# Виконати scaffold
dotnet ef dbcontext scaffold "$CONNECTION" "$PROVIDER" \
    --project "$PROJECT" \
    --startup-project "$STARTUP" \
    --output-dir "Generated/Entities" \
    --context-dir "Generated" \
    --context "ShopDbContext" \
    --namespace "YourApp.Infrastructure.Generated.Entities" \
    --context-namespace "YourApp.Infrastructure.Generated" \
    --no-onconfiguring \
    --force

echo "✅ Scaffold completed!"
echo ""
echo "⚠️  Post-scaffold checklist:"
echo "   1. Review git diff for any breaking changes"
echo "   2. Check if new entities need Extensions classes"
echo "   3. Check if removed columns affect Extensions code"
echo "   4. Run tests: dotnet test"

# 1. Зберегти поточний стан у Git перед scaffold
git add .
git commit -m "chore: pre-rescaffold checkpoint"

# 2. Виконати re-scaffold
./scripts/rescaffold.sh

# 3. Перевірити що змінилось
git diff --stat
# Показує які файли змінились і скільки рядків

# 4. Детальний diff для review
git diff Infrastructure/Generated/

# 5. Перевірити що Extensions не зачіпнуті
git diff Infrastructure/Extensions/
# Повинно бути: нічого (порожньо)

# 6. Запустити тести
dotnet test

# 7. Закомітити якщо все в порядку
git add .
git commit -m "chore: re-scaffold after DB schema update v3.2"

// Product.Extensions.cs — ПІСЛЯ re-scaffold Product більше не має поля Discount!
public partial class Product
{
    // ❌ Compilation Error: Product не має Discount після re-scaffold
    public bool IsDiscounted => Discount.HasValue && Discount.Value > 0;
}

# Генерує SQL DDL для поточної EF Core моделі (без міграцій!)
dotnet ef dbcontext script -o current-model.sql

dotnet add package EFCore.SchemaCompare

using EfSchemaCompare;

// Порівнює C# модель (DbContext) з реальною схемою БД
var comparer = new CompareEfSql();
var hasErrors = comparer.CompareEfWithDb(context);

if (hasErrors)
{
    // Виводить детальний звіт
    Console.WriteLine(comparer.GetAllErrors);
    // Example:
    // DIFFERENT: Entity 'Product', column 'Price': column type. Expected = decimal(18,2), found = decimal(10,2)
    // MISSING: Entity 'OrderLineItem', index 'IX_OrderLineItems_OrderId' not found in database.
    // EXTRA: Table 'Tmp_Products' in database, not in entity classes.
}
else
{
    Console.WriteLine("EF Core model matches database schema perfectly.");
}

[Fact]
public void EfCoreModel_ShouldMatchDatabaseSchema()
{
    using var context = GetTestContext(); // реальна тестова БД

    var comparer  = new CompareEfSql();
    var hasErrors = comparer.CompareEfWithDb(context);

    Assert.False(hasErrors, $"Schema differences:\n{comparer.GetAllErrors}");
}

Redgate SQL Compare:
- Порівнює схеми: Dev ↔ Staging ↔ Production
- Генерує delta SQL скрипти
- Інтеграція з SQL Server, MySQL, PostgreSQL
- CLI версія для CI/CD pipeline

-- PostgreSQL: вбудований information_schema для ручного порівняння
SELECT table_schema, table_name, column_name, data_type, is_nullable
FROM information_schema.columns
WHERE table_schema NOT IN ('information_schema', 'pg_catalog')
ORDER BY table_schema, table_name, ordinal_position;

-- Або через pg_dump + diff:
pg_dump --schema-only prod_db > prod_schema.sql
pg_dump --schema-only dev_db  > dev_schema.sql
diff prod_schema.sql dev_schema.sql

// Два DbContext для двох різних БД
public class OrdersDbContext : DbContext
{
    public OrdersDbContext(DbContextOptions<OrdersDbContext> options) : base(options) { }

    public DbSet<Order>       Orders      => Set<Order>();
    public DbSet<OrderItem>   OrderItems  => Set<OrderItem>();
}

public class InventoryDbContext : DbContext
{
    public InventoryDbContext(DbContextOptions<InventoryDbContext> options) : base(options) { }

    public DbSet<Product>     Products    => Set<Product>();
    public DbSet<StockLevel>  StockLevels => Set<StockLevel>();
}

// Program.cs: окремі DbContext для окремих БД
builder.Services.AddDbContext<OrdersDbContext>(options =>
    options.UseSqlServer(
        builder.Configuration.GetConnectionString("OrdersDb")));

builder.Services.AddDbContext<InventoryDbContext>(options =>
    options.UseNpgsql(
        builder.Configuration.GetConnectionString("InventoryDb")));

// appsettings.json:
// {
//   "ConnectionStrings": {
//     "OrdersDb":    "Server=orders-sql;Database=Orders;...",
//     "InventoryDb": "Host=inventory-pg;Database=Inventory;..."
//   }
// }

public class OrderFulfillmentService
{
    private readonly OrdersDbContext    _ordersDb;
    private readonly InventoryDbContext _inventoryDb;

    // Два DbContext — з різних БД, різних провайдерів!
    public OrderFulfillmentService(
        OrdersDbContext ordersDb,
        InventoryDbContext inventoryDb)
    {
        _ordersDb    = ordersDb;
        _inventoryDb = inventoryDb;
    }

    public async Task FulfillOrderAsync(int orderId)
    {
        // Читаємо з OrdersDb
        var order = await _ordersDb.Orders
            .Include(o => o.Items)
            .FirstOrDefaultAsync(o => o.Id == orderId)
            ?? throw new NotFoundException($"Order {orderId} not found.");

        // Резервуємо товар в InventoryDb
        foreach (var item in order.Items)
        {
            var rowsAffected = await _inventoryDb.StockLevels
                .Where(s => s.ProductId == item.ProductId && s.Available >= item.Quantity)
                .ExecuteUpdateAsync(s =>
                    s.SetProperty(sl => sl.Available, sl => sl.Available - item.Quantity));

            if (rowsAffected == 0)
                throw new InsufficientStockException(item.ProductId);
        }

        // Оновлюємо статус в OrdersDb
        order.Status    = "Fulfilled";
        order.FulfilledAt = DateTime.UtcNow;
        await _ordersDb.SaveChangesAsync();
    }
}

# Запускаємо міграції окремо для кожного DbContext!
dotnet ef migrations add InitOrders --context OrdersDbContext
dotnet ef migrations add InitInventory --context InventoryDbContext

# Database update для кожного теж окремо:
dotnet ef database update --context OrdersDbContext
dotnet ef database update --context InventoryDbContext

// OrdersDbContext: міграції у Migrations/Orders/
builder.Services.AddDbContext<OrdersDbContext>(options =>
    options.UseSqlServer(connectionString, sqlOptions =>
        sqlOptions.MigrationsAssembly("YourApp.Infrastructure")
                  // Або через налаштування MigrationsHistoryTable зі своїм prefix
    ));

// Або через конфігурацію контексту:
public class OrdersDbContext : DbContext
{
    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.HasDefaultSchema("orders"); // власна схема для ізоляції
        // Тоді __EFMigrationsHistory буде у схемі "orders"
    }
}

// Tenant-per-database: DbContext створюється динамічно з правильним connection string
public class TenantDbContextFactory
{
    private readonly ITenantResolver _tenantResolver;
    private readonly IConfiguration  _configuration;

    public TenantDbContextFactory(
        ITenantResolver tenantResolver,
        IConfiguration  configuration)
    {
        _tenantResolver = tenantResolver;
        _configuration  = configuration;
    }

    public AppDbContext CreateForCurrentTenant()
    {
        var tenantId         = _tenantResolver.GetCurrentTenantId();
        var connectionString = GetConnectionStringForTenant(tenantId);

        var options = new DbContextOptionsBuilder<AppDbContext>()
            .UseSqlServer(connectionString)
            .Options;

        return new AppDbContext(options);
    }

    private string GetConnectionStringForTenant(string tenantId)
    {
        // Читаємо з конфігурації або з "master" бази
        return _configuration[$"Tenants:{tenantId}:ConnectionString"]
            ?? throw new InvalidOperationException($"No connection string for tenant {tenantId}");
    }
}

// Реєстрація через IDbContextFactory:
builder.Services.AddDbContextFactory<AppDbContext>((serviceProvider, options) =>
{
    var tenantResolver   = serviceProvider.GetRequiredService<ITenantResolver>();
    var tenantId         = tenantResolver.GetCurrentTenantId();
    var configuration    = serviceProvider.GetRequiredService<IConfiguration>();
    var connectionString = configuration[$"Tenants:{tenantId}:ConnectionString"];

    options.UseSqlServer(connectionString);
});

// Два DbContext: WriteDbContext → master, ReadDbContext → replica
public class WriteDbContext : AppDbContext
{
    public WriteDbContext(DbContextOptions<WriteDbContext> options) : base(options) { }
}

public class ReadDbContext : AppDbContext
{
    public ReadDbContext(DbContextOptions<ReadDbContext> options) : base(options) { }

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        base.OnConfiguring(optionsBuilder);
        // Read context: глобально NoTracking (все read-only)
        optionsBuilder.UseQueryTrackingBehavior(QueryTrackingBehavior.NoTracking);
    }
}

// Реєстрація:
builder.Services.AddDbContext<WriteDbContext>(options =>
    options.UseSqlServer(masterConnectionString));

builder.Services.AddDbContext<ReadDbContext>(options =>
    options.UseSqlServer(replicaConnectionString));

// Використання в CQRS:
public class GetOrderQueryHandler : IRequestHandler<GetOrderQuery, OrderDto>
{
    private readonly ReadDbContext _readDb;  // ← завжди read replica

    public async Task<OrderDto> Handle(GetOrderQuery request, CancellationToken ct)
    {
        return await _readDb.Orders
            .Select(o => new OrderDto { ... })
            .FirstOrDefaultAsync(o => o.Id == request.OrderId, ct)
            ?? throw new NotFoundException();
    }
}

public class PlaceOrderCommandHandler : IRequestHandler<PlaceOrderCommand, int>
{
    private readonly WriteDbContext _writeDb;  // ← завжди master

    public async Task<int> Handle(PlaceOrderCommand request, CancellationToken ct)
    {
        var order = new Order { ... };
        _writeDb.Orders.Add(order);
        await _writeDb.SaveChangesAsync(ct);
        return order.Id;
    }
}

// OnModelCreating — детальна конфігурація
modelBuilder.Entity<Product>(entity =>
{
    entity.ToTable("Products");
    entity.HasKey(e => e.Id);
    entity.Property(e => e.Name)
          .IsRequired()
          .HasMaxLength(200);
    entity.Property(e => e.Price)
          .HasColumnType("decimal(10,2)");
    entity.HasCheckConstraint("CK_Price_Positive", "[Price] >= 0");

    entity.HasOne(e => e.Category)
          .WithMany(e => e.Products)
          .HasForeignKey(e => e.CategoryId)
          .HasConstraintName("FK_Products_Categories");
});

// Infrastructure/Configurations/ProductConfiguration.cs
// Цей файл НЕ генерується scaffold — пишеться розробником
public class ProductConfiguration : IEntityTypeConfiguration<Product>
{
    public void Configure(EntityTypeBuilder<Product> builder)
    {
        // Конфігурація яку НЕ генерує scaffold (тільки наша):
        builder.HasQueryFilter(p => p.IsActive);  // Global Query Filter
        builder.Property(p => p.Name).UseCollation("SQL_Latin1_General_CP1_CS_AS");
    }
}

// ShopDbContextExtensions.cs (наш файл, не scaffold):
public partial class ShopDbContext
{
    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        base.OnModelCreating(modelBuilder); // ← scaffold конфігурація

        // Застосувати наші додаткові конфігурації
        modelBuilder.ApplyConfigurationsFromAssembly(
            typeof(ProductConfiguration).Assembly,
            t => t.Namespace?.Contains(".Configurations") == true);  // фільтр за namespace
    }
}