feat(ef-core): migrate from Dapper to Entity Framework Core

Replace Dapper raw SQL with EF Core LINQ queries for type-safe,
multi-provider database access (SQL Server, MySQL, PostgreSQL).

- Add 6 entity models mapping to existing database tables
- Create OrderMonitorDbContext with Fluent API configuration
- Implement EfCoreOrderRepository with LINQ-based stuck order queries
- Add DatabaseProviderFactory for multi-provider DbContext creation
- Extract IDiagnosticsService interface for schema discovery
- Create DiagnosticsService using EF Core model metadata
- Update DI registration to use EF Core instead of Dapper
- Remove Dapper, Microsoft.Data.SqlClient dependencies
- Add EF Core packages: SqlServer 10.0.3, MySQL 10.0.1, Npgsql 10.0.0
- Add 50 unit tests (entities, DbContext, repository, provider factory)

Closes BD-847

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: ranganathan2020

src/OrderMonitor.Api/Controllers/DiagnosticsController.cs

@@ -1,23 +1,23 @@
-using Dapper;
 using Microsoft.AspNetCore.Mvc;
 using OrderMonitor.Core.Interfaces;
 
 namespace OrderMonitor.Api.Controllers;
 
 /// <summary>
 /// Diagnostic endpoints for debugging and schema discovery.
+/// Uses EF Core metadata instead of raw INFORMATION_SCHEMA queries.
 /// </summary>
 [ApiController]
 [Route("api/[controller]")]
 [Produces("application/json")]
 public class DiagnosticsController : ControllerBase
 {
-    private readonly IDbConnectionFactory _connectionFactory;
+    private readonly IDiagnosticsService _diagnosticsService;
     private readonly ILogger<DiagnosticsController> _logger;
 
-    public DiagnosticsController(IDbConnectionFactory connectionFactory, ILogger<DiagnosticsController> logger)
+    public DiagnosticsController(IDiagnosticsService diagnosticsService, ILogger<DiagnosticsController> logger)
     {
-        _connectionFactory = connectionFactory;
+        _diagnosticsService = diagnosticsService;
         _logger = logger;
     }
 
@@ -29,13 +29,12 @@ public async Task<IActionResult> GetOrderTables()
     {
         try
         {
-            using var conn = _connectionFactory.CreateConnection();
-            var tables = await conn.QueryAsync<string>(
-                "SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME LIKE '%Order%' ORDER BY TABLE_NAME");
+            var tables = await _diagnosticsService.GetOrderTablesAsync();
             return Ok(tables);
         }
         catch (Exception ex)
         {
+            _logger.LogError(ex, "Error retrieving order tables");
             return StatusCode(500, new { error = ex.Message });
         }
     }
@@ -48,17 +47,12 @@ public async Task<IActionResult> GetTableColumns(string tableName)
     {
         try
         {
-            using var conn = _connectionFactory.CreateConnection();
-            var columns = await conn.QueryAsync<dynamic>(
-                @"SELECT COLUMN_NAME, DATA_TYPE, IS_NULLABLE, CHARACTER_MAXIMUM_LENGTH
-                  FROM INFORMATION_SCHEMA.COLUMNS
-                  WHERE TABLE_NAME = @TableName
-                  ORDER BY ORDINAL_POSITION",
-                new { TableName = tableName });
+            var columns = await _diagnosticsService.GetTableColumnsAsync(tableName);
             return Ok(columns);
         }
         catch (Exception ex)
         {
+            _logger.LogError(ex, "Error retrieving columns for table {TableName}", tableName);
             return StatusCode(500, new { error = ex.Message });
         }
     }
@@ -78,12 +72,12 @@ public async Task<IActionResult> RunQuery([FromBody] QueryRequest request)
 
         try
         {
-            using var conn = _connectionFactory.CreateConnection();
-            var results = await conn.QueryAsync<dynamic>(request.Sql);
-            return Ok(results.Take(100)); // Limit to 100 rows
+            var results = await _diagnosticsService.RunSelectQueryAsync(request.Sql);
+            return Ok(results);
         }
         catch (Exception ex)
         {
+            _logger.LogError(ex, "Error running diagnostic query");
             return StatusCode(500, new { error = ex.Message });
         }
     }

src/OrderMonitor.Core/Interfaces/IDbConnectionFactory.cs

@@ -0,0 +1,33 @@
+namespace OrderMonitor.Core.Interfaces;
+
+/// <summary>
+/// Service interface for database diagnostics and schema discovery.
+/// </summary>
+public interface IDiagnosticsService
+{
+    /// <summary>
+    /// Gets table names containing 'Order' from the database model.
+    /// </summary>
+    Task<IEnumerable<string>> GetOrderTablesAsync();
+
+    /// <summary>
+    /// Gets column information for a specific table.
+    /// </summary>
+    Task<IEnumerable<ColumnInfo>> GetTableColumnsAsync(string tableName);
+
+    /// <summary>
+    /// Runs a SELECT-only SQL query and returns results.
+    /// </summary>
+    Task<IEnumerable<IDictionary<string, object?>>> RunSelectQueryAsync(string sql);
+}
+
+/// <summary>
+/// Represents column metadata for a database table.
+/// </summary>
+public class ColumnInfo
+{
+    public string ColumnName { get; set; } = string.Empty;
+    public string DataType { get; set; } = string.Empty;
+    public string IsNullable { get; set; } = string.Empty;
+    public int? CharacterMaximumLength { get; set; }
+}

src/OrderMonitor.Core/Interfaces/IDiagnosticsService.cs

@@ -0,0 +1,49 @@
+using Microsoft.EntityFrameworkCore;
+
+namespace OrderMonitor.Infrastructure.Data;
+
+/// <summary>
+/// Factory for creating DbContextOptions configured for the specified database provider.
+/// Supports SQL Server, MySQL, and PostgreSQL.
+/// </summary>
+public static class DatabaseProviderFactory
+{
+    /// <summary>
+    /// Creates DbContextOptions for the specified provider and connection string.
+    /// </summary>
+    /// <param name="provider">Database provider: "sqlserver", "mysql", or "postgresql"</param>
+    /// <param name="connectionString">The database connection string</param>
+    /// <returns>Configured DbContextOptions</returns>
+    public static DbContextOptions<OrderMonitorDbContext> CreateOptions(
+        string provider,
+        string connectionString)
+    {
+        if (string.IsNullOrWhiteSpace(connectionString))
+            throw new ArgumentException("Connection string cannot be null or empty.", nameof(connectionString));
+
+        if (string.IsNullOrWhiteSpace(provider))
+            throw new ArgumentException("Provider cannot be null or empty.", nameof(provider));
+
+        var builder = new DbContextOptionsBuilder<OrderMonitorDbContext>();
+
+        switch (provider.ToLowerInvariant())
+        {
+            case "sqlserver":
+                builder.UseSqlServer(connectionString);
+                break;
+            case "mysql":
+                builder.UseMySQL(connectionString);
+                break;
+            case "postgresql":
+            case "postgres":
+                builder.UseNpgsql(connectionString);
+                break;
+            default:
+                throw new ArgumentException(
+                    $"Unsupported database provider: '{provider}'. Supported providers: sqlserver, mysql, postgresql.",
+                    nameof(provider));
+        }
+
+        return builder.Options;
+    }
+}

src/OrderMonitor.Infrastructure/Data/DatabaseProviderFactory.cs

@@ -0,0 +1,117 @@
+using Microsoft.EntityFrameworkCore;
+using OrderMonitor.Core.Interfaces;
+
+namespace OrderMonitor.Infrastructure.Data;
+
+/// <summary>
+/// EF Core-based diagnostics service.
+/// Uses model metadata for schema discovery instead of INFORMATION_SCHEMA queries.
+/// </summary>
+public class DiagnosticsService : IDiagnosticsService
+{
+    private readonly OrderMonitorDbContext _context;
+
+    public DiagnosticsService(OrderMonitorDbContext context)
+    {
+        _context = context ?? throw new ArgumentNullException(nameof(context));
+    }
+
+    /// <inheritdoc />
+    public Task<IEnumerable<string>> GetOrderTablesAsync()
+    {
+        var entityTypes = _context.Model.GetEntityTypes()
+            .Select(e => e.GetTableName())
+            .Where(t => t != null && t.Contains("Order", StringComparison.OrdinalIgnoreCase))
+            .Cast<string>()
+            .OrderBy(t => t)
+            .AsEnumerable();
+
+        return Task.FromResult(entityTypes);
+    }
+
+    /// <inheritdoc />
+    public Task<IEnumerable<ColumnInfo>> GetTableColumnsAsync(string tableName)
+    {
+        var entityType = _context.Model.GetEntityTypes()
+            .FirstOrDefault(e => string.Equals(e.GetTableName(), tableName, StringComparison.OrdinalIgnoreCase));
+
+        if (entityType == null)
+            return Task.FromResult(Enumerable.Empty<ColumnInfo>());
+
+        var columns = entityType.GetProperties()
+            .Select(p =>
+            {
+                var column = p.GetColumnName();
+                var clrType = p.ClrType;
+                var isNullable = p.IsNullable ? "YES" : "NO";
+                var maxLength = p.GetMaxLength();
+
+                return new ColumnInfo
+                {
+                    ColumnName = column ?? p.Name,
+                    DataType = MapClrTypeToSqlType(clrType),
+                    IsNullable = isNullable,
+                    CharacterMaximumLength = maxLength
+                };
+            })
+            .OrderBy(c => c.ColumnName)
+            .AsEnumerable();
+
+        return Task.FromResult(columns);
+    }
+
+    /// <inheritdoc />
+    public async Task<IEnumerable<IDictionary<string, object?>>> RunSelectQueryAsync(string sql)
+    {
+        var results = new List<IDictionary<string, object?>>();
+
+        var connection = _context.Database.GetDbConnection();
+        await connection.OpenAsync();
+
+        try
+        {
+            using var command = connection.CreateCommand();
+            command.CommandText = sql;
+
+            using var reader = await command.ExecuteReaderAsync();
+            var count = 0;
+            while (await reader.ReadAsync() && count < 100)
+            {
+                var row = new Dictionary<string, object?>();
+                for (int i = 0; i < reader.FieldCount; i++)
+                {
+                    row[reader.GetName(i)] = reader.IsDBNull(i) ? null : reader.GetValue(i);
+                }
+                results.Add(row);
+                count++;
+            }
+        }
+        finally
+        {
+            if (connection.State == System.Data.ConnectionState.Open)
+                await connection.CloseAsync();
+        }
+
+        return results;
+    }
+
+    private static string MapClrTypeToSqlType(Type clrType)
+    {
+        var underlying = Nullable.GetUnderlyingType(clrType) ?? clrType;
+
+        return underlying.Name switch
+        {
+            "String" => "nvarchar",
+            "Int32" => "int",
+            "Int64" => "bigint",
+            "Boolean" => "bit",
+            "DateTime" => "datetime2",
+            "Decimal" => "decimal",
+            "Double" => "float",
+            "Single" => "real",
+            "Guid" => "uniqueidentifier",
+            "Byte[]" => "varbinary",
+            _ => underlying.Name.ToLower()
+        };
+    }
+}