Create database for Sql Server resource

src/Aspire.Hosting.SqlServer/SqlServerBuilderExtensions.cs

@@ -3,7 +3,9 @@
 
 using Aspire.Hosting;
 using Aspire.Hosting.ApplicationModel;
+using Microsoft.Data.SqlClient;
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
 
 namespace Aspire.Hosting;
 
@@ -45,6 +47,42 @@ public static IResourceBuilder<SqlServerServerResource> AddSqlServer(this IDistr
             }
         });
 
+        builder.Eventing.Subscribe<ResourceReadyEvent>(sqlServer, async (@event, ct) =>
+        {
+            if (connectionString is null)
+            {
+                throw new DistributedApplicationException($"ResourceReadyEvent was published for the '{sqlServer.Name}' resource but the connection string was null.");
+            }
+
+            using var sqlConnection = new SqlConnection(connectionString);
+            await sqlConnection.OpenAsync(ct).ConfigureAwait(false);
+
+            foreach (var sqlDatabase in sqlServer.DatabaseResources)
+            {
+                var quotedDatabaseIdentifier = new SqlCommandBuilder().QuoteIdentifier(sqlDatabase.DatabaseName);
+
+                try
+                {
+                    if (sqlConnection.State != System.Data.ConnectionState.Open)
+                    {
+                        throw new InvalidOperationException($"Could not open connection to '{sqlServer.Name}'");
+                    }
+
+                    var scriptAnnotation = sqlDatabase.Annotations.OfType<ScriptAnnotation>().LastOrDefault();
+
+                    using var command = sqlConnection.CreateCommand();
+                    command.CommandText = scriptAnnotation?.Script ??
+                        $"IF ( NOT EXISTS ( SELECT 1 FROM sys.databases WHERE name = @DatabaseName ) ) CREATE DATABASE {quotedDatabaseIdentifier};";
+                    command.Parameters.Add(new SqlParameter("@DatabaseName", sqlDatabase.DatabaseName));
+                    await command.ExecuteNonQueryAsync(ct).ConfigureAwait(false);
+                }
+                catch (Exception e)
+                {
+                    @event.Services.GetRequiredService<ILogger<SqlServerServerResource>>().LogError(e, "Failed to create database '{DatabaseName}'", sqlDatabase.DatabaseName);
+                }
+            }
+        });
+
         var healthCheckKey = $"{name}_check";
         builder.Services.AddHealthChecks().AddSqlServer(sp => connectionString ?? throw new InvalidOperationException("Connection string is unavailable"), name: healthCheckKey);
 
@@ -72,12 +110,31 @@ public static IResourceBuilder<SqlServerDatabaseResource> AddDatabase(this IReso
         ArgumentNullException.ThrowIfNull(builder);
         ArgumentException.ThrowIfNullOrEmpty(name);
 
+        string? connectionString = null;
+
         // Use the resource name as the database name if it's not provided
         databaseName ??= name;
 
-        builder.Resource.AddDatabase(name, databaseName);
         var sqlServerDatabase = new SqlServerDatabaseResource(name, databaseName, builder.Resource);
-        return builder.ApplicationBuilder.AddResource(sqlServerDatabase);
+
+        builder.Resource.AddDatabase(sqlServerDatabase);
+
+        builder.ApplicationBuilder.Eventing.Subscribe<ConnectionStringAvailableEvent>(sqlServerDatabase, async (@event, ct) =>
+        {
+            connectionString = await sqlServerDatabase.ConnectionStringExpression.GetValueAsync(ct).ConfigureAwait(false);
+
+            if (connectionString == null)
+            {
+                throw new DistributedApplicationException($"ConnectionStringAvailableEvent was published for the '{name}' resource but the connection string was null.");
+            }
+        });
+
+        var healthCheckKey = $"{name}_check";
+        builder.ApplicationBuilder.Services.AddHealthChecks().AddSqlServer(sp => connectionString ?? throw new InvalidOperationException("Connection string is unavailable"), name: healthCheckKey);
+
+        return builder.ApplicationBuilder
+            .AddResource(sqlServerDatabase)
+            .WithHealthCheck(healthCheckKey);
     }
 
     /// <summary>
@@ -112,4 +169,23 @@ public static IResourceBuilder<SqlServerServerResource> WithDataBindMount(this I
 
         return builder.WithBindMount(source, "/var/opt/mssql", isReadOnly);
     }
+
+    /// <summary>
+    /// Alters the JSON configuration document used by the emulator.
+    /// </summary>
+    /// <param name="builder">The builder for the <see cref="SqlServerDatabaseResource"/>.</param>
+    /// <param name="script">The SQL script used to create the database.</param>
+    /// <returns>A reference to the <see cref="IResourceBuilder{T}"/>.</returns>
+    /// <remarks>
+    /// <value>Default script is <code>IF ( NOT EXISTS ( SELECT 1 FROM sys.databases WHERE name = @DatabaseName ) ) CREATE DATABASE [&lt;QUOTED_DATABASE_NAME%gt;];</code></value>
+    /// </remarks>
+    public static IResourceBuilder<SqlServerDatabaseResource> WithCreationScript(this IResourceBuilder<SqlServerDatabaseResource> builder, string script)
+    {
+        ArgumentNullException.ThrowIfNull(builder);
+        ArgumentNullException.ThrowIfNull(script);
+
+        builder.WithAnnotation(new ScriptAnnotation(script));
+
+        return builder;
+    }
 }

src/Aspire.Hosting.SqlServer/SqlServerDatabaseResource.cs

@@ -3,6 +3,7 @@
 
 using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
+using Microsoft.Data.SqlClient;
 
 namespace Aspire.Hosting.ApplicationModel;
 
@@ -23,8 +24,18 @@ public class SqlServerDatabaseResource(string name, string databaseName, SqlServ
     /// <summary>
     /// Gets the connection string expression for the SQL Server database.
     /// </summary>
-    public ReferenceExpression ConnectionStringExpression =>
-        ReferenceExpression.Create($"{Parent};Database={DatabaseName}");
+    public ReferenceExpression ConnectionStringExpression
+    {
+        get
+        {
+            var connectionStringBuilder = new SqlConnectionStringBuilder
+            {
+                ["Database"] = DatabaseName
+            };
+
+            return ReferenceExpression.Create($"{Parent};{connectionStringBuilder.ToString()}");
+        }
+    }
 
     /// <summary>
     /// Gets the database name.

src/Aspire.Hosting.SqlServer/SqlServerServerResource.cs

@@ -69,14 +69,18 @@ public ReferenceExpression ConnectionStringExpression
     }
 
     private readonly Dictionary<string, string> _databases = new(StringComparers.ResourceName);
+    private readonly List<SqlServerDatabaseResource> _databaseResources = [];
 
     /// <summary>
     /// A dictionary where the key is the resource name and the value is the database name.
     /// </summary>
     public IReadOnlyDictionary<string, string> Databases => _databases;
 
-    internal void AddDatabase(string name, string databaseName)
+    internal void AddDatabase(SqlServerDatabaseResource database)
     {
-        _databases.TryAdd(name, databaseName);
+        _databases.TryAdd(database.Name, database.DatabaseName);
+        _databaseResources.Add(database);
     }
+
+    internal IReadOnlyList<SqlServerDatabaseResource> DatabaseResources => _databaseResources;
 }

src/Aspire.Hosting/ApplicationModel/ScriptAnnotation.cs

@@ -0,0 +1,25 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Aspire.Hosting.ApplicationModel;
+
+/// <summary>
+/// Represents an annotation for defining a script to create a resource.
+/// </summary>
+public sealed class ScriptAnnotation : IResourceAnnotation
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ScriptAnnotation"/> class.
+    /// </summary>
+    /// <param name="script">The script used to create the resource.</param>
+    public ScriptAnnotation(string script)
+    {
+        ArgumentNullException.ThrowIfNull(script);
+        Script = script;
+    }
+
+    /// <summary>
+    /// Gets the script used to create the resource.
+    /// </summary>
+    public string Script { get; }
+}

tests/Aspire.Hosting.SqlServer.Tests/AddSqlServerTests.cs

@@ -116,8 +116,8 @@ public async Task SqlServerDatabaseCreatesConnectionString()
         var connectionStringResource = (IResourceWithConnectionString)sqlResource;
         var connectionString = await connectionStringResource.GetConnectionStringAsync();
 
-        Assert.Equal("Server=127.0.0.1,1433;User ID=sa;Password=p@ssw0rd1;TrustServerCertificate=true;Database=mydb", connectionString);
-        Assert.Equal("{sqlserver.connectionString};Database=mydb", connectionStringResource.ConnectionStringExpression.ValueExpression);
+        Assert.Equal("Server=127.0.0.1,1433;User ID=sa;Password=p@ssw0rd1;TrustServerCertificate=true;Initial Catalog=mydb", connectionString);
+        Assert.Equal("{sqlserver.connectionString};Initial Catalog=mydb", connectionStringResource.ConnectionStringExpression.ValueExpression);
     }
 
     [Fact]
@@ -154,7 +154,7 @@ public async Task VerifyManifest()
         expectedManifest = """
             {
               "type": "value.v0",
-              "connectionString": "{sqlserver.connectionString};Database=db"
+              "connectionString": "{sqlserver.connectionString};Initial Catalog=db"
             }
             """;
         Assert.Equal(expectedManifest, dbManifest.ToString());
@@ -228,8 +228,8 @@ public void CanAddDatabasesWithDifferentNamesOnSingleServer()
         Assert.Equal("customers1", db1.Resource.DatabaseName);
         Assert.Equal("customers2", db2.Resource.DatabaseName);
 
-        Assert.Equal("{sqlserver1.connectionString};Database=customers1", db1.Resource.ConnectionStringExpression.ValueExpression);
-        Assert.Equal("{sqlserver1.connectionString};Database=customers2", db2.Resource.ConnectionStringExpression.ValueExpression);
+        Assert.Equal("{sqlserver1.connectionString};Initial Catalog=customers1", db1.Resource.ConnectionStringExpression.ValueExpression);
+        Assert.Equal("{sqlserver1.connectionString};Initial Catalog=customers2", db2.Resource.ConnectionStringExpression.ValueExpression);
     }
 
     [Fact]
@@ -246,7 +246,7 @@ public void CanAddDatabasesWithTheSameNameOnMultipleServers()
         Assert.Equal("imports", db1.Resource.DatabaseName);
         Assert.Equal("imports", db2.Resource.DatabaseName);
 
-        Assert.Equal("{sqlserver1.connectionString};Database=imports", db1.Resource.ConnectionStringExpression.ValueExpression);
-        Assert.Equal("{sqlserver2.connectionString};Database=imports", db2.Resource.ConnectionStringExpression.ValueExpression);
+        Assert.Equal("{sqlserver1.connectionString};Initial Catalog=imports", db1.Resource.ConnectionStringExpression.ValueExpression);
+        Assert.Equal("{sqlserver2.connectionString};Initial Catalog=imports", db2.Resource.ConnectionStringExpression.ValueExpression);
     }
 }