Update database migration and seeding logic; adjust Docker port mapping

web/backend/Database/Database.Migrations/Program.cs

@@ -7,215 +7,211 @@ using Microsoft.Data.SqlClient;
 namespace Database.Migrations;
 
 /// <summary>
-///     Entry point for the database migration runner. Reads connection details from
+///     Entry point for the database migration runner. Reads connection details from environment
-///     environment variables, optionally clears and recreates the target database, and
+///     variables, optionally drops and recreates the target database, and applies all SQL
-///     applies all SQL migration scripts embedded in this assembly using DbUp.
+///     migration scripts embedded in this assembly using DbUp.
 /// </summary>
 public static class Program
 {
-    /// <summary>The connection string for the target application database (<c>DB_NAME</c>).</summary>
+    /// <summary>
-    private static readonly string connectionString = BuildConnectionString();
+    ///     Migration runner entry point. Drops the target database when <c>CLEAR_DATABASE</c> is
+    ///     set to <c>true</c>, ensures the database exists, then deploys all pending migrations.
+    /// </summary>
+    /// <returns>
+    ///     <c>0</c> if migrations completed successfully; <c>1</c> if they failed or an error occurred.
+    /// </returns>
+    public static async Task<int> Main()
+    {
+        Console.WriteLine("Starting database migrations...");
 
-    /// <summary>The connection string for the <c>master</c> database, used for create/drop operations.</summary>
+        try
-    private static readonly string masterConnectionString = BuildConnectionString("master");
+        {
+            DatabaseSettings settings = DatabaseSettings.FromEnvironment();
+
+            if (settings.ClearDatabase)
+            {
+                Console.WriteLine(
+                    $"CLEAR_DATABASE is enabled. Dropping database '{settings.DatabaseName}'..."
+                );
+                await DropDatabaseIfExistsAsync(settings);
+            }
+
+            await CreateDatabaseIfNotExistsAsync(settings);
+
+            return DeployMigrations(settings.ConnectionString) ? 0 : 1;
+        }
+        catch (Exception ex) when (ex is InvalidOperationException or SqlException)
+        {
+            Console.Error.WriteLine("An error occurred during database migrations:");
+            Console.Error.WriteLine(ex.Message);
+            return 1;
+        }
+    }
 
     /// <summary>
-    ///     Builds a SQL Server connection string from the <c>DB_SERVER</c>, <c>DB_NAME</c>,
+    ///     Drops the target database if it exists, first forcing it into single-user mode with
-    ///     <c>DB_USER</c>, <c>DB_PASSWORD</c>, and <c>DB_TRUST_SERVER_CERTIFICATE</c>
+    ///     rollback immediate so that any existing connections are terminated.
-    ///     environment variables.
     /// </summary>
-    /// <param name="databaseName">
+    /// <param name="settings">The resolved database settings.</param>
-    ///     The database (initial catalog) to connect to. When <c>null</c>, falls back to the
+    /// <exception cref="SqlException">Thrown if the connection or the drop operation fails.</exception>
-    ///     <c>DB_NAME</c> environment variable.
+    private static async Task DropDatabaseIfExistsAsync(DatabaseSettings settings)
-    /// </param>
-    /// <returns>A fully built SQL Server connection string.</returns>
-    /// <exception cref="InvalidOperationException">
-    ///     Thrown when <c>DB_SERVER</c>, <c>DB_USER</c>, <c>DB_PASSWORD</c>, or (when
-    ///     <paramref name="databaseName" /> is <c>null</c>) <c>DB_NAME</c> is not set.
-    /// </exception>
-    private static string BuildConnectionString(string? databaseName = null)
     {
-        string server =
+        const string sql = """
-            Environment.GetEnvironmentVariable("DB_SERVER")
+            DECLARE @statement nvarchar(max);
-            ?? throw new InvalidOperationException("DB_SERVER environment variable is not set");
 
-        string dbName =
+            IF EXISTS (SELECT 1 FROM sys.databases WHERE name = @databaseName)
-            databaseName
+            BEGIN
-            ?? Environment.GetEnvironmentVariable("DB_NAME")
+                SET @statement =
-            ?? throw new InvalidOperationException("DB_NAME environment variable is not set");
+                    N'ALTER DATABASE ' + QUOTENAME(@databaseName)
+                    + N' SET SINGLE_USER WITH ROLLBACK IMMEDIATE;';
+                EXEC sys.sp_executesql @statement;
 
-        string user =
+                SET @statement = N'DROP DATABASE ' + QUOTENAME(@databaseName) + N';';
-            Environment.GetEnvironmentVariable("DB_USER")
+                EXEC sys.sp_executesql @statement;
-            ?? throw new InvalidOperationException("DB_USER environment variable is not set");
+            END
+            """;
 
-        string password =
+        await ExecuteNonQueryAsync(settings.MasterConnectionString, sql, settings.DatabaseName);
-            Environment.GetEnvironmentVariable("DB_PASSWORD")
+        Console.WriteLine($"Database '{settings.DatabaseName}' dropped, or did not exist.");
-            ?? throw new InvalidOperationException("DB_PASSWORD environment variable is not set");
+    }
 
-        string trustServerCertificate =
+    /// <summary>
-            Environment.GetEnvironmentVariable("DB_TRUST_SERVER_CERTIFICATE") ?? "True";
+    ///     Creates the target database on the <c>master</c> connection if it does not already exist.
+    /// </summary>
+    /// <param name="settings">The resolved database settings.</param>
+    /// <exception cref="SqlException">Thrown if the connection or the create operation fails.</exception>
+    private static async Task CreateDatabaseIfNotExistsAsync(DatabaseSettings settings)
+    {
+        const string sql = """
+            DECLARE @statement nvarchar(max);
 
-        SqlConnectionStringBuilder builder = new()
+            IF NOT EXISTS (SELECT 1 FROM sys.databases WHERE name = @databaseName)
-        {
+            BEGIN
-            DataSource = server,
+                SET @statement = N'CREATE DATABASE ' + QUOTENAME(@databaseName) + N';';
-            InitialCatalog = dbName,
+                EXEC sys.sp_executesql @statement;
-            UserID = user,
+            END
-            Password = password,
+            """;
-            TrustServerCertificate = bool.Parse(trustServerCertificate),
-            Encrypt = true,
-        };
 
-        return builder.ConnectionString;
+        await ExecuteNonQueryAsync(settings.MasterConnectionString, sql, settings.DatabaseName);
+        Console.WriteLine($"Database '{settings.DatabaseName}' is present.");
+    }
+
+    /// <summary>
+    ///     Opens a connection, executes a non-query batch parameterised by database name, and
+    ///     disposes both the command and the connection.
+    /// </summary>
+    /// <param name="connectionString">The connection string to open.</param>
+    /// <param name="sql">The Transact-SQL batch to execute.</param>
+    /// <param name="databaseName">The value bound to the <c>@databaseName</c> parameter.</param>
+    private static async Task ExecuteNonQueryAsync(
+        string connectionString,
+        string sql,
+        string databaseName
+    )
+    {
+        await using SqlConnection connection = new(connectionString);
+        await connection.OpenAsync();
+
+        await using SqlCommand command = new(sql, connection);
+        command.Parameters.Add("@databaseName", SqlDbType.NVarChar, 128).Value = databaseName;
+
+        await command.ExecuteNonQueryAsync();
     }
 
     /// <summary>
     ///     Applies all pending SQL migration scripts embedded in this assembly to the target
     ///     database using DbUp, logging progress to the console.
     /// </summary>
+    /// <param name="connectionString">The connection string for the target application database.</param>
     /// <returns><c>true</c> if the upgrade completed successfully; otherwise <c>false</c>.</returns>
-    private static bool DeployMigrations()
+    private static bool DeployMigrations(string connectionString)
     {
-        UpgradeEngine? upgrader = DeployChanges
+        UpgradeEngine upgrader = DeployChanges
             .To.SqlDatabase(connectionString)
             .WithScriptsEmbeddedInAssembly(Assembly.GetExecutingAssembly())
+            .WithTransactionPerScript()
             .LogToConsole()
             .Build();
 
-        DatabaseUpgradeResult? result = upgrader.PerformUpgrade();
+        DatabaseUpgradeResult result = upgrader.PerformUpgrade();
-        return result.Successful;
+
+        if (result.Successful)
+        {
+            Console.WriteLine("Database migrations completed successfully.");
+            return true;
+        }
+
+        Console.Error.WriteLine($"Database migrations failed: {result.Error}");
+        return false;
     }
 
     /// <summary>
-    ///     Drops the <c>Biergarten</c> database if it exists, first forcing it into single-user
+    ///     Connection details and runtime options resolved from environment variables.
-    ///     mode with rollback to terminate any existing connections.
     /// </summary>
-    /// <returns>
+    /// <param name="ConnectionString">The connection string for the target application database.</param>
-    ///     <c>true</c> if the database was dropped (or did not exist) without error; <c>false</c>
+    /// <param name="MasterConnectionString">
-    ///     if an error occurred while connecting or dropping the database.
+    ///     The connection string for the <c>master</c> database, used for create and drop operations.
-    /// </returns>
+    /// </param>
-    private static bool ClearDatabase()
+    /// <param name="DatabaseName">The name of the target application database.</param>
+    /// <param name="ClearDatabase">Whether the target database should be dropped before migrating.</param>
+    private sealed record DatabaseSettings(
+        string ConnectionString,
+        string MasterConnectionString,
+        string DatabaseName,
+        bool ClearDatabase
+    )
     {
-        SqlConnection myConn = new(masterConnectionString);
+        /// <summary>
-
+        ///     Builds the settings from the <c>DB_SERVER</c>, <c>DB_NAME</c>, <c>DB_USER</c>,
-        try
+        ///     <c>DB_PASSWORD</c>, <c>DB_TRUST_SERVER_CERTIFICATE</c>, and <c>CLEAR_DATABASE</c>
+        ///     environment variables.
+        /// </summary>
+        /// <exception cref="InvalidOperationException">
+        ///     Thrown when a required environment variable is not set.
+        /// </exception>
+        public static DatabaseSettings FromEnvironment()
         {
-            myConn.Open();
+            string server = Required("DB_SERVER");
+            string databaseName = Required("DB_NAME");
+            string user = Required("DB_USER");
+            string password = Required("DB_PASSWORD");
 
-            // First, set the database to single user mode to close all connections
+            bool trustServerCertificate =
-            SqlCommand setModeCommand = new(
+                !bool.TryParse(
-                "IF EXISTS (SELECT 1 FROM sys.databases WHERE name = 'Biergarten') "
+                    Environment.GetEnvironmentVariable("DB_TRUST_SERVER_CERTIFICATE"),
-                    + "ALTER DATABASE [Biergarten] SET SINGLE_USER WITH ROLLBACK IMMEDIATE;",
+                    out bool parsedTrust
-                myConn
+                )
+                || parsedTrust;
+
+            bool clearDatabase = string.Equals(
+                Environment.GetEnvironmentVariable("CLEAR_DATABASE"),
+                "true",
+                StringComparison.OrdinalIgnoreCase
             );
-            try
-            {
-                setModeCommand.ExecuteNonQuery();
-                Console.WriteLine("Database set to single user mode.");
-            }
-            catch (Exception ex)
-            {
-                Console.WriteLine($"Warning: Could not set single user mode: {ex.Message}");
-            }
 
-            // Then drop the database
+            return new DatabaseSettings(
-            SqlCommand dropCommand = new("DROP DATABASE IF EXISTS [Biergarten];", myConn);
+                Build(databaseName),
-            try
+                Build("master"),
-            {
+                databaseName,
-                dropCommand.ExecuteNonQuery();
+                clearDatabase
-                Console.WriteLine("Database cleared successfully.");
+            );
-            }
+
-            catch (Exception ex)
+            string Build(string initialCatalog) =>
-            {
+                new SqlConnectionStringBuilder
-                Console.WriteLine($"Error dropping database: {ex}");
+                {
-                return false;
+                    DataSource = server,
-            }
+                    InitialCatalog = initialCatalog,
-        }
+                    UserID = user,
-        catch (Exception ex)
+                    Password = password,
-        {
+                    Encrypt = true,
-            Console.WriteLine($"Error clearing database: {ex}");
+                    TrustServerCertificate = trustServerCertificate
-            return false;
+                }.ConnectionString;
-        }
-        finally
-        {
-            if (myConn.State == ConnectionState.Open)
-                myConn.Close();
         }
 
-        return true;
+        private static string Required(string variableName) =>
+            Environment.GetEnvironmentVariable(variableName)
+            ?? throw new InvalidOperationException(
+                $"The {variableName} environment variable is not set."
+            );
     }
-
+}
-    /// <summary>
-    ///     Creates the <c>Biergarten</c> database on the master connection if it does not
-    ///     already exist. Errors encountered while creating the database are logged but do
-    ///     not stop execution.
-    /// </summary>
-    /// <returns><c>true</c> always; this method does not propagate database errors as a failure result.</returns>
-    private static bool CreateDatabaseIfNotExists()
-    {
-        SqlConnection myConn = new(masterConnectionString);
-
-        const string str = """
-            IF NOT EXISTS (SELECT 1 FROM sys.databases WHERE name = 'Biergarten')
-            CREATE DATABASE [Biergarten]
-            """;
-
-        SqlCommand myCommand = new(str, myConn);
-        try
-        {
-            myConn.Open();
-            myCommand.ExecuteNonQuery();
-            Console.WriteLine("Database creation command executed successfully.");
-        }
-        catch (Exception ex)
-        {
-            Console.WriteLine($"Error creating database: {ex}");
-        }
-        finally
-        {
-            if (myConn.State == ConnectionState.Open)
-                myConn.Close();
-        }
-
-        return true;
-    }
-
-    /// <summary>
-    ///     Migration runner entry point. Optionally clears the existing database when the
-    ///     <c>CLEAR_DATABASE</c> environment variable is set to <c>"true"</c>, ensures the
-    ///     database exists, then deploys all pending migrations.
-    /// </summary>
-    /// <param name="args">Command-line arguments (unused).</param>
-    /// <returns><c>0</c> if migrations completed successfully; <c>1</c> if they failed or an error occurred.</returns>
-    public static int Main(string[] args)
-    {
-        Console.WriteLine("Starting database migrations...");
-
-        try
-        {
-            string? clearDatabase = Environment.GetEnvironmentVariable("CLEAR_DATABASE");
-            if (clearDatabase == "true")
-            {
-                Console.WriteLine("CLEAR_DATABASE is enabled. Clearing existing database...");
-                ClearDatabase();
-            }
-
-            CreateDatabaseIfNotExists();
-            bool success = DeployMigrations();
-
-            if (success)
-            {
-                Console.WriteLine("Database migrations completed successfully.");
-                return 0;
-            }
-
-            Console.WriteLine("Database migrations failed.");
-            return 1;
-        }
-        catch (Exception ex)
-        {
-            Console.WriteLine("An error occurred during database migrations:");
-            Console.WriteLine(ex.Message);
-            return 1;
-        }
-    }
-}

web/backend/Database/Database.Seed/DatabaseHelpers/ConnectionStrings.cs

@@ -1,4 +1,8 @@
-using Microsoft.Data.SqlClient;
+#region
+
+using Microsoft.Data.SqlClient;
+
+#endregion
 
 namespace Database.Seed.DatabaseHelpers;
 
@@ -9,23 +13,23 @@ public class ConnectionStrings
 
     private static string GetSqlServerConnectionString()
     {
-        var server =
+        string server =
             Environment.GetEnvironmentVariable("DB_SERVER")
             ?? throw new InvalidOperationException("DB_SERVER environment variable is not set");
 
-        var dbName =
+        string dbName =
             Environment.GetEnvironmentVariable("DB_NAME")
             ?? throw new InvalidOperationException("DB_NAME environment variable is not set");
 
-        var user =
+        string user =
             Environment.GetEnvironmentVariable("DB_USER")
             ?? throw new InvalidOperationException("DB_USER environment variable is not set");
 
-        var password =
+        string password =
             Environment.GetEnvironmentVariable("DB_PASSWORD")
             ?? throw new InvalidOperationException("DB_PASSWORD environment variable is not set");
 
-        var trustServerCertificate =
+        string trustServerCertificate =
             Environment.GetEnvironmentVariable("DB_TRUST_SERVER_CERTIFICATE") ?? "True";
 
         SqlConnectionStringBuilder builder = new()

web/backend/Database/Database.Seed/Program.cs

@@ -1,3 +1,5 @@
+
+
 using Database.Seed.DatabaseHelpers;
 using Database.Seed.PipelineData;
 using Database.Seed.Sqlite;
@@ -10,74 +12,67 @@ using Microsoft.Data.Sqlite;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 
-namespace Database.Seed;
 
-public class Program
+IReadOnlyList<BreweryRecord> breweries;
+IReadOnlyList<UserRecord> users;
+try
 {
-    public static int Main()
+    PipelineSeedDataReader reader = new(ConnectionStrings.SqliteConnectionString);
-    {
+    breweries = reader.ReadBreweryRecords();
-        IReadOnlyList<BreweryRecord> breweries;
+    users = reader.ReadUserRecords();
-        IReadOnlyList<UserRecord> users;
+}
-        try
+catch (SqliteException ex)
-        {
+{
-            PipelineSeedDataReader reader = new(ConnectionStrings.SqliteConnectionString);
+    Console.ForegroundColor = ConsoleColor.Red;
-            breweries = reader.ReadBreweryRecords();
+    Console.WriteLine($"Error opening database connection: {ex.Message}");
-            users = reader.ReadUserRecords();
+    Console.ResetColor();
-        }
+    return 1;
-        catch (SqliteException ex)
+}
-        {
-            Console.ForegroundColor = ConsoleColor.Red;
-            Console.WriteLine($"Error opening database connection: {ex.Message}");
-            Console.ResetColor();
-            return 1;
-        }
 
-        ServiceCollection services = new();
+ServiceCollection services = [];
-        services.AddSingleton<IConfiguration>(new ConfigurationBuilder().Build());
+services.AddSingleton<IConfiguration>(new ConfigurationBuilder().Build());
-        services.AddSingleton<ISqlConnectionFactory, DefaultSqlConnectionFactory>();
+services.AddSingleton<ISqlConnectionFactory, DefaultSqlConnectionFactory>();
-        services.AddFeaturesBreweries();
+services.AddFeaturesBreweries();
-        services.AddFeaturesAuth();
+services.AddFeaturesAuth();
 
-        using ServiceProvider provider = services.BuildServiceProvider();
+using ServiceProvider provider = services.BuildServiceProvider();
 
-        IBreweryRepository breweryRepository;
+IBreweryRepository breweryRepository;
-        IAuthRepository authRepository;
+IAuthRepository authRepository;
-        try
+try
-        {
+{
-            breweryRepository = provider.GetRequiredService<IBreweryRepository>();
+    breweryRepository = provider.GetRequiredService<IBreweryRepository>();
-            authRepository = provider.GetRequiredService<IAuthRepository>();
+    authRepository = provider.GetRequiredService<IAuthRepository>();
-        }
+}
-        catch (InvalidOperationException ex)
+catch (InvalidOperationException ex)
-        {
+{
-            Console.ForegroundColor = ConsoleColor.Red;
+    Console.ForegroundColor = ConsoleColor.Red;
-            Console.WriteLine($"Error configuring database connection: {ex.Message}");
+    Console.WriteLine($"Error configuring database connection: {ex.Message}");
-            Console.ResetColor();
+    Console.ResetColor();
-            return 1;
+    return 1;
-        }
+}
 
-        Console.ForegroundColor = ConsoleColor.Green;
+Console.ForegroundColor = ConsoleColor.Green;
-        Console.WriteLine(
+Console.WriteLine(
-            $"Loaded {breweries.Count} breweries."
+    $"Loaded {breweries.Count} breweries."
-        );
+);
-        Console.ResetColor();
+Console.ResetColor();
 
-        for (var i = 0; i < breweries.Count; i++)
+for (int i = 0; i < breweries.Count; i++)
-        {
+{
-            BreweryRecord brewery = breweries[i];
+    BreweryRecord brewery = breweries[i];
-            Console.WriteLine(
+    Console.WriteLine(
-                $"{i + 1}:\t{brewery.Brewery.NameEn}\t({brewery.Address.City.CityName}, {brewery.Address.City.Country})");
+        $"{i + 1}:\t{brewery.Brewery.NameEn}\t({brewery.Address.City.CityName}, {brewery.Address.City.Country})");
-        }
+}
 
-        Console.ForegroundColor = ConsoleColor.Green;
+Console.ForegroundColor = ConsoleColor.Green;
-        Console.WriteLine($"Loaded {users.Count} users.");
+Console.WriteLine($"Loaded {users.Count} users.");
-        Console.ResetColor();
+Console.ResetColor();
 
-        for (var i = 0; i < users.Count; i++)
+for (int i = 0; i < users.Count; i++)
-        {
+{
-            UserRecord user = users[i];
+    UserRecord user = users[i];
-            Console.WriteLine($"{i + 1}:\t{user.User.FirstName} {user.User.LastName}\t ({user.Email})");
+    Console.WriteLine($"{i + 1}:\t{user.User.FirstName} {user.User.LastName}\t ({user.Email})");
-        }
+}
 
-        return 0;
+return 0;
-    }
-}

web/backend/Database/Database.Seed/Sqlite/PipelineSeedDataReader.cs

@@ -1,7 +1,11 @@
+#region
+
 using System.Text.Json;
 using Database.Seed.PipelineData;
 using Microsoft.Data.Sqlite;
 
+#endregion
+
 namespace Database.Seed.Sqlite;
 
 public sealed class PipelineSeedDataReader

web/docker-compose.db.yaml

@@ -9,7 +9,7 @@ services:
       SA_PASSWORD: "${DB_PASSWORD}"
       MSSQL_PID: "Express"
     ports:
-      - "1433:1433"
+      - "1434:1433"
     volumes:
       - sqlserverdata-dev:/var/opt/mssql
     healthcheck:

web/docker-compose.dev.yaml

@@ -9,7 +9,7 @@ services:
       SA_PASSWORD: "${DB_PASSWORD}"
       MSSQL_PID: "Express"
     ports:
-      - "1433:1433"
+      - "1434:1433"
     volumes:
       - sqlserverdata-dev:/var/opt/mssql
     healthcheck: