Enhance issue request management and webhook handling

- Introduced `IssueRequestRepository` and `IssueRequestEntity` classes for managing issue requests with CRUD operations.
- Improved `SaveWebhookAsync` in `GitHubWebhookRepository` to handle webhook data more effectively.
- Updated `SqlDbStorageContext` with a new `CreateConnectionAsync` method and enhanced error handling for entity operations.
- Added `SqlTableHelper` for managing SQL table creation and validation.
- Modified `GitHubWebhookEntity` to include new properties for better webhook delivery tracking.
- Overall improvements to code robustness and maintainability.

Author: calin-lupas_dsamcaps

src/DevExcelerateApi/Data/GitHubWebhookRepository.cs

@@ -11,12 +11,14 @@ namespace DevExcelerateApi.Data
     public class GitHubWebhookRepository(IStorageContext<GitHubWebhookEntity> storageContext) 
         : Repository<GitHubWebhookEntity>(storageContext)
     {
-
         public Task SaveWebhookAsync(WebhookHeaders headers, WebhookEvent webhookEvent)
         {
             var webhookEntity = new GitHubWebhookEntity
             {
-                GitHubDelivery = headers?.Delivery!,
+                Id = headers?.Delivery!,
+                GitHubHook = headers?.HookId,
+                GitHubEvent = $"{headers?.Event}.{webhookEvent?.Action}",
+                SenderLogin = webhookEvent?.Sender?.Login,
                 Headers = JsonSerializer.Serialize(headers),
                 Payload = JsonSerializer.Serialize(webhookEvent)
             };

src/DevExcelerateApi/Data/IssueRequestRepository.cs

@@ -0,0 +1,92 @@
+using DevExcelerateApi.Models;
+
+namespace DevExcelerateApi.Data
+{
+    /// <summary>
+    /// Repository for Issue Request entities.
+    /// Demonstrates how easy it is to create repositories for new entity types.
+    /// </summary>
+    /// <param name="storageContext">The storage context for IssueRequestEntity</param>
+    public class IssueRequestRepository(IStorageContext<IssueRequestEntity> storageContext) 
+        : Repository<IssueRequestEntity>(storageContext)
+    {
+        /// <summary>
+        /// Saves an issue request with additional business logic.
+        /// </summary>
+        /// <param name="repositoryName">The repository name</param>
+        /// <param name="issueNumber">The issue number</param>
+        /// <param name="title">The issue title</param>
+        /// <param name="body">The issue body</param>
+        /// <param name="createdBy">The user who created the issue</param>
+        /// <returns>The created issue request entity</returns>
+        public async Task<IssueRequestEntity> CreateIssueRequestAsync(
+            string repositoryName,
+            long issueNumber,
+            string title,
+            string? body = null,
+            string? createdBy = null)
+        {
+            var issueRequest = new IssueRequestEntity
+            {
+                RepositoryName = repositoryName,
+                IssueNumber = issueNumber,
+                Title = title,
+                Body = body,
+                CreatedBy = createdBy,
+                State = "open"
+            };
+
+            await CreateAsync(issueRequest);
+            return issueRequest;
+        }
+
+        /// <summary>
+        /// Finds all issue requests for a specific repository.
+        /// </summary>
+        /// <param name="repositoryName">The repository name</param>
+        /// <returns>List of issue requests for the repository</returns>
+        public async Task<IEnumerable<IssueRequestEntity>> FindByRepositoryAsync(string repositoryName)
+        {
+            return await StorageContext.QueryEntitiesAsync(entity => 
+                entity.RepositoryName?.Equals(repositoryName, StringComparison.OrdinalIgnoreCase) == true);
+        }
+
+        /// <summary>
+        /// Finds issue requests by state.
+        /// </summary>
+        /// <param name="state">The issue state (open, closed, etc.)</param>
+        /// <returns>List of issue requests with the specified state</returns>
+        public async Task<IEnumerable<IssueRequestEntity>> FindByStateAsync(string state)
+        {
+            return await StorageContext.QueryEntitiesAsync(entity => 
+                entity.State?.Equals(state, StringComparison.OrdinalIgnoreCase) == true);
+        }
+
+        /// <summary>
+        /// Updates the state of an issue request.
+        /// </summary>
+        /// <param name="issueRequestId">The issue request ID</param>
+        /// <param name="newState">The new state</param>
+        /// <param name="partition">The partition key (optional)</param>
+        public async Task UpdateStateAsync(string issueRequestId, string newState, string? partition = null)
+        {
+            var issueRequest = await FindByIdAsync(issueRequestId, partition);
+            issueRequest.State = newState;
+            issueRequest.UpdatedOn = DateTimeOffset.UtcNow;
+            
+            await UpsertAsync(issueRequest);
+        }
+
+        /// <summary>
+        /// Finds issue requests created within a date range.
+        /// </summary>
+        /// <param name="startDate">Start date</param>
+        /// <param name="endDate">End date</param>
+        /// <returns>List of issue requests created within the date range</returns>
+        public async Task<IEnumerable<IssueRequestEntity>> FindByDateRangeAsync(DateTimeOffset startDate, DateTimeOffset endDate)
+        {
+            return await StorageContext.QueryEntitiesAsync(entity => 
+                entity.CreatedOn >= startDate && entity.CreatedOn <= endDate);
+        }
+    }
+}

src/DevExcelerateApi/Data/SqlDbStorageContext.cs

@@ -5,72 +5,160 @@
 
 namespace DevExcelerateApi.Data;
 
+/// <summary>
+/// SQL Database storage context that creates entity-specific tables for each IStorageEntity type.
+/// Each entity type gets its own table with a consistent schema pattern.
+/// </summary>
+/// <typeparam name="T">The entity type that implements IStorageEntity</typeparam>
 public class SqlDbStorageContext<T> : IStorageContext<T>, IDisposable where T : IStorageEntity
 {
     private readonly SqlDbOptions _sqlDbOptions;
+    private readonly string _tableName;
+    private bool _disposed = false;
 
     public SqlDbStorageContext(SqlDbOptions sqlDbOptions)
     {
-        _sqlDbOptions = sqlDbOptions ?? throw new ArgumentNullException("SqlDb");
+        _sqlDbOptions = sqlDbOptions ?? throw new ArgumentNullException(nameof(sqlDbOptions));
+        _tableName = SqlTableHelper.GetTableName<T>();
+        
+        if (!SqlTableHelper.IsValidTableName(_tableName))
+        {
+            throw new ArgumentException($"Invalid table name generated for entity type '{typeof(T).Name}': '{_tableName}'");
+        }
     }
 
-    public Task<IEnumerable<T>> QueryEntitiesAsync(Func<T, bool> predicate)
+    /// <summary>
+    /// Creates a new SQL connection and ensures the table exists.
+    /// </summary>
+    /// <returns>A configured SQL connection</returns>
+    private async Task<SqlConnection> CreateConnectionAsync()
     {
-        // could use extensions for dapper at https://github.com/tmsmith/Dapper-Extensions using the GetList Operation (with Predicates). To be tested
-        throw new NotImplementedException();
+        var connection = new SqlConnection(_sqlDbOptions.ConnectionString);
+        await connection.OpenAsync();
+        await SqlTableHelper.EnsureTableExistsAsync(connection, _tableName);
+        return connection;
+    }
+
+    public async Task<IEnumerable<T>> QueryEntitiesAsync(Func<T, bool> predicate)
+    {
+        using var connection = await CreateConnectionAsync();
+        
+        var sql = SqlTableHelper.GetQueryAllEntitiesSql(_tableName);
+        var jsonDataList = await connection.QueryAsync<string>(sql);
+        
+        var entities = jsonDataList
+            .Select(jsonData => JsonSerializer.Deserialize<T>(jsonData)!)
+            .Where(predicate);
+            
+        return entities;
     }
 
     public async Task<T> ReadAsync(string entityId, string partitionKey)
     {
-        using (var connection = new SqlConnection(_sqlDbOptions.ConnectionString))
+        if (string.IsNullOrWhiteSpace(entityId))
+        {
+            throw new ArgumentOutOfRangeException(nameof(entityId), "Entity Id cannot be null or empty.");
+        }
+
+        using var connection = await CreateConnectionAsync();
+        
+        var sql = SqlTableHelper.GetReadEntitySql(_tableName);
+        var jsonData = await connection.QueryFirstOrDefaultAsync<string>(sql, new { EntityId = entityId, PartitionKey = partitionKey });
+        
+        if (jsonData == null)
         {
-            var jsonData = await connection.QueryFirstAsync<string>(
-                "SELECT EventData FROM [WebhookEvents] WHERE EventId = @Id AND EventType = @EventType",
-                new { Id = entityId, EventType = typeof(T).Name });
-            return JsonSerializer.Deserialize<T>(jsonData)!;
+            throw new KeyNotFoundException($"Entity with id '{entityId}' and partition '{partitionKey}' not found in table '{_tableName}'.");
         }
+        
+        return JsonSerializer.Deserialize<T>(jsonData)!;
     }
 
     public async Task CreateAsync(T entity)
     {
-        using (var connection = new SqlConnection(_sqlDbOptions.ConnectionString))
+        if (string.IsNullOrWhiteSpace(entity.Id))
+        {
+            throw new ArgumentOutOfRangeException(nameof(entity), "Entity Id cannot be null or empty.");
+        }
+
+        using var connection = await CreateConnectionAsync();
+        
+        var sql = SqlTableHelper.GetInsertEntitySql(_tableName);
+            
+        try
+        {
+            await connection.ExecuteAsync(sql, new
+            {
+                EntityId = entity.Id,
+                PartitionKey = entity.Partition,
+                EntityData = JsonSerializer.Serialize(entity)
+            });
+        }
+        catch (SqlException ex) when (ex.Number == 2627) // Unique constraint violation
         {
-            await connection.ExecuteAsync(
-                "INSERT INTO [WebhookEvents] ([EventId], [EventType],[EventData]) VALUES (@EventId, @EventType, @EventData)",
-                new { EventId = entity.Id, EventType = typeof(T).Name, EventData = JsonSerializer.Serialize(entity) });
+            throw new InvalidOperationException($"Entity with id '{entity.Id}' and partition '{entity.Partition}' already exists in table '{_tableName}'.", ex);
         }
     }
 
     public async Task UpsertAsync(T entity)
     {
-        using (var connection = new SqlConnection(_sqlDbOptions.ConnectionString))
+        if (string.IsNullOrWhiteSpace(entity.Id))
         {
-            var exists = await connection.ExecuteScalarAsync<bool>(
-                "SELECT COUNT(1) FROM [WebhookEvents] WHERE EventId = @Id AND EventType = @EventType",
-                new { Id = entity.Id, EventType = typeof(T).Name });
-            if (exists)
-            {
-                await connection.ExecuteAsync(
-                    "UPDATE [WebhookEvents] SET EventData = @EventData WHERE EventId = @Id AND EventType = @EventType",
-                    new { Id = entity.Id, EventType = typeof(T).Name, EventData = JsonSerializer.Serialize(entity) });
-            }
-            else
+            throw new ArgumentOutOfRangeException(nameof(entity), "Entity Id cannot be null or empty.");
+        }
+
+        using var connection = await CreateConnectionAsync();
+        
+        var checkSql = SqlTableHelper.GetEntityExistsSql(_tableName);
+        var exists = await connection.ExecuteScalarAsync<bool>(checkSql, new { EntityId = entity.Id, PartitionKey = entity.Partition });
+        
+        if (exists)
+        {
+            var updateSql = SqlTableHelper.GetUpdateEntitySql(_tableName);
+                
+            await connection.ExecuteAsync(updateSql, new
             {
-                await CreateAsync(entity);
-            }
+                EntityId = entity.Id,
+                PartitionKey = entity.Partition,
+                EntityData = JsonSerializer.Serialize(entity)
+            });
+        }
+        else
+        {
+            await CreateAsync(entity);
         }
     }
 
     public async Task DeleteAsync(T entity)
     {
-        using (var connection = new SqlConnection(_sqlDbOptions.ConnectionString))
+        if (string.IsNullOrWhiteSpace(entity.Id))
+        {
+            throw new ArgumentOutOfRangeException(nameof(entity), "Entity Id cannot be null or empty.");
+        }
+
+        using var connection = await CreateConnectionAsync();
+        
+        var sql = SqlTableHelper.GetDeleteEntitySql(_tableName);
+        var rowsAffected = await connection.ExecuteAsync(sql, new { EntityId = entity.Id, PartitionKey = entity.Partition });
+        
+        if (rowsAffected == 0)
         {
-            await connection.ExecuteAsync("DELETE FROM [WebhookEvents] WHERE EventId = @Id AND EventType = @EventType",
-                new { Id = entity.Id, EventType = typeof(T).Name });
+            throw new KeyNotFoundException($"Entity with id '{entity.Id}' and partition '{entity.Partition}' not found in table '{_tableName}'.");
         }
     }
 
     public void Dispose()
     {
+        Dispose(true);
+        GC.SuppressFinalize(this);
+    }
+
+    protected virtual void Dispose(bool disposing)
+    {
+        if (!_disposed && disposing)
+        {
+            // No specific resources to dispose in this implementation
+            // Connection disposal is handled in the using statements
+        }
+        _disposed = true;
     }
 }