db changes + event repo regorganisation

Author: Skyfall1235

src/RandomAPI/APIServices/Services/DatabaseService.cs

@@ -24,7 +24,7 @@ public void Execute(Action<SqliteConnection> action)
     /// <summary>
     /// Opens a connection, executes a Dapper query, and returns a collection of results.
     /// </summary>
-    /// <typeparam name="T">The type of object to map the result rows to (e.g., Event).</typeparam>
+    /// <typeparam name="T">The Type of object to map the result rows to (e.g., Event).</typeparam>
     /// <param name="sql">The SQL SELECT statement to execute.</param>
     /// <param name="param">Optional parameters object for Dapper.</param>
     /// <returns>A collection of mapped objects.</returns>
@@ -55,7 +55,7 @@ public async Task<int> ExecuteAsync(string sql, object? param = null)
     /// <summary>
     /// Opens a connection, executes a command, and returns a single value (e.g., the last inserted ID).
     /// </summary>
-    /// <typeparam name="T">The type of the scalar result (e.g., int).</typeparam>
+    /// <typeparam name="T">The Type of the scalar result (e.g., int).</typeparam>
     /// <param name="sql">The SQL command to execute.</param>
     /// <param name="param">Optional parameters object for Dapper.</param>
     /// <returns>The single scalar result.</returns>

src/RandomAPI/Repository/DBInitialization.cs

@@ -7,17 +7,25 @@ namespace RandomAPI.Repository
 {
     public class EventRepository : IEventRepository, IInitializer
     {
-        private readonly IDbConnection _db;
+        private readonly Func<IDbConnection> _connectionFactory;
         private readonly ILogger<EventRepository> _logger;
 
-        public EventRepository(IDbConnection db, ILogger<EventRepository> logger)
+        public EventRepository(Func<IDbConnection> connectionFactory, ILogger<EventRepository> logger)
         {
-            _db = db;
+            _connectionFactory = connectionFactory;
             _logger = logger;
         }
 
+        private IDbConnection CreateConnection()
+        {
+            var conn = _connectionFactory();
+            conn.Open();
+            return conn;
+        }
+
         public async Task InitializeAsync()
         {
+            using var db = CreateConnection();
             var sql =
                     @"
         CREATE TABLE IF NOT EXISTS Events (
@@ -30,12 +38,13 @@ CREATE TABLE IF NOT EXISTS Events (
             EventId     TEXT NOT NULL,
             CONSTRAINT UQ_EventId UNIQUE (EventId)
         );";
-            await _db.ExecuteAsync(sql);
+            await db.ExecuteAsync(sql);
         }
 
         /// <inheritdoc />
         public async Task<int> AddEventAsync(Event eventModel)
         {
+            using var db = CreateConnection();
             const string sql =
                 @"
                 INSERT INTO Events (Timestamp, EventId, Service, Type, DataType, JsonData) 
@@ -45,7 +54,7 @@ INSERT INTO Events (Timestamp, EventId, Service, Type, DataType, JsonData)
 
             try
             {
-                var newId = await _db.ExecuteScalarAsync<int>(sql, eventModel);
+                var newId = await db.ExecuteScalarAsync<int>(sql, eventModel);
                 return newId;
             }
             catch (SqliteException ex) when (ex.SqliteErrorCode == 19) // Error code 19 is 'CONSTRAINT'
@@ -54,7 +63,7 @@ INSERT INTO Events (Timestamp, EventId, Service, Type, DataType, JsonData)
                     $"WARNING: Duplicate event detected. EventId: {eventModel.EventId}"
                 );
                 const string selectExistingSql = "SELECT Id FROM Events WHERE EventId = @EventId";
-                var existingId = await _db.ExecuteScalarAsync<int>(
+                var existingId = await db.ExecuteScalarAsync<int>(
                     selectExistingSql,
                     new { eventModel.EventId }
                 );
@@ -70,19 +79,21 @@ INSERT INTO Events (Timestamp, EventId, Service, Type, DataType, JsonData)
         /// <inheritdoc />
         public async Task<IEnumerable<Event>> GetAllEventsAsync()
         {
+            using var db = CreateConnection();
             // Retrieves all records, ordered by newest first.
             const string sql = "SELECT * FROM Events ORDER BY Timestamp DESC";
 
-            var events = await _db.QueryAsync<Event>(sql);
+            var events = await db.QueryAsync<Event>(sql);
             return events;
         }
 
         /// <inheritdoc />
         public async Task<IEnumerable<Event>> GetRangeOfRecentEventsAsync(int count)
         {
+            using var db = CreateConnection();
             const string sql = "SELECT * FROM Events ORDER BY Timestamp DESC LIMIT @Count";
 
-            var events = await _db.QueryAsync<Event>(sql, new { Count = count });
+            var events = await db.QueryAsync<Event>(sql, new { Count = count });
             return events;
         }
 
@@ -92,18 +103,20 @@ public async Task<IEnumerable<Event>> GetEventsByIdsAsync(IEnumerable<int> ids)
             if (ids == null || !ids.Any())
                 return Enumerable.Empty<Event>();
 
+            using var db = CreateConnection();
             const string sql = "SELECT * FROM Events WHERE Id IN @Ids ORDER BY Timestamp DESC";
 
-            var events = await _db.QueryAsync<Event>(sql, new { Ids = ids });
+            var events = await db.QueryAsync<Event>(sql, new { Ids = ids });
             return events;
         }
 
         /// <inheritdoc />
         public async Task<int> RemoveEventAsync(int id)
         {
+            using var db = CreateConnection();
             const string sql = "DELETE FROM Events WHERE Id = @Id";
 
-            var rowsAffected = await _db.ExecuteAsync(sql, new { Id = id });
+            var rowsAffected = await db.ExecuteAsync(sql, new { Id = id });
             return rowsAffected;
         }
 
@@ -112,11 +125,13 @@ public async Task<int> RemoveEventsByIdsAsync(IEnumerable<int> ids)
         {
             if (ids == null || !ids.Any())
                 return 0;
-
+            using var db = CreateConnection();
             const string sql = "DELETE FROM Events WHERE Id IN @Ids";
 
-            var rowsAffected = await _db.ExecuteAsync(sql, new { Ids = ids });
+            var rowsAffected = await db.ExecuteAsync(sql, new { Ids = ids });
             return rowsAffected;
         }
     }
 }
+
+