Merge pull request #681 from ErikEJ/sqlproject-delay

fixes #638

Author: ErikEJ

examples/sql-database-projects/CommunityToolkit.Aspire.Hosting.SqlDatabaseProjects.AppHost/Program.cs

@@ -21,4 +21,8 @@
 builder.AddSqlProject<Projects.SdkProject>("existing-db")
         .WithReference(connection);
 
+var delayedProject = builder.AddSqlProject<Projects.SdkProject>("sdk-project-delayed")
+       .WithReference(database)
+       .WithExplicitStart();
+
 builder.Build().Run();

src/CommunityToolkit.Aspire.Hosting.SqlDatabaseProjects/SqlProjectBuilderExtensions.cs

@@ -198,35 +198,68 @@ internal static IResourceBuilder<TResource> InternalWithReference<TResource>(thi
         {
             builder.ApplicationBuilder.Eventing.Subscribe<ResourceReadyEvent>(target.Resource, async (resourceReady, ct) =>
             {
-                await RunPublish(builder, target, targetDatabaseName, resourceReady.Services, ct);
+                await PublishOrMark(builder, target, targetDatabaseName, resourceReady.Services, ct);
             });
         }
-        else 
+        else
         {
-            builder.ApplicationBuilder.Eventing.Subscribe<AfterResourcesCreatedEvent>(async (@event, ct) => {
-                await RunPublish(builder, target, targetDatabaseName, @event.Services, ct);
+            builder.ApplicationBuilder.Eventing.Subscribe<AfterResourcesCreatedEvent>(async (@event, ct) => 
+            {
+                await PublishOrMark(builder, target, targetDatabaseName, @event.Services, ct);
             });
         }
 
         builder.WaitFor(target);
 
-        builder.WithCommand("redeploy", "Redeploy", async (context) =>
-        {
-            var service = context.ServiceProvider.GetRequiredService<SqlProjectPublishService>();
-            await service.PublishSqlProject(builder.Resource, target.Resource, targetDatabaseName, context.CancellationToken);
-            return new ExecuteCommandResult { Success = true };
-        }, new CommandOptions()
+        var commandOptions = new CommandOptions
         {
-            Description = "Redeploys the SQL Server Database Project to the target database.",
             IconName = "ArrowReset",
             IconVariant = IconVariant.Filled,
             IsHighlighted = true,
-            UpdateState = (context) => context.ResourceSnapshot?.State?.Text == KnownResourceStates.Finished ? ResourceCommandState.Enabled : ResourceCommandState.Disabled,
-        });
+            Description = "Deploy the SQL Server Database Project to the target database.",
+            UpdateState = (context) =>
+            {
+                if (context.ResourceSnapshot?.State?.Text is string stateText && (stateText == KnownResourceStates.Finished || stateText == KnownResourceStates.NotStarted))
+                {
+                    return ResourceCommandState.Enabled;
+                }
+                else
+                {
+                    return ResourceCommandState.Disabled;
+                }
+            },
+        };           
+
+        builder.WithCommand("deploy", "Deploy", async (context) =>
+        {
+            var service = context.ServiceProvider.GetRequiredService<SqlProjectPublishService>();
+            await service.PublishSqlProject(builder.Resource, target.Resource, targetDatabaseName, context.CancellationToken);
+            return new ExecuteCommandResult { Success = true };
+        }, commandOptions);
 
         return builder;
     }
 
+    private static async Task PublishOrMark<TResource>(IResourceBuilder<TResource> builder, IResourceBuilder<IResourceWithConnectionString> target, string? targetDatabaseName, IServiceProvider services, CancellationToken ct) where TResource : IResourceWithDacpac
+    {
+        if (builder.Resource.HasAnnotationOfType<ExplicitStartupAnnotation>())
+        {
+            await MarkNotStarted(builder, services);
+        }
+        else
+        {
+            await RunPublish(builder, target, targetDatabaseName, services, ct);
+        }
+    }
+
+    private static async Task MarkNotStarted<TResource>(IResourceBuilder<TResource> builder, IServiceProvider serviceProvider)
+        where TResource : IResourceWithDacpac
+    {
+        var resourceNotificationService = serviceProvider.GetRequiredService<ResourceNotificationService>();
+        await resourceNotificationService.PublishUpdateAsync(builder.Resource,
+            state => state with { State = new ResourceStateSnapshot(KnownResourceStates.NotStarted, KnownResourceStateStyles.Info) });
+    }
+
     private static async Task RunPublish<TResource>(IResourceBuilder<TResource> builder, IResourceBuilder<IResourceWithConnectionString> target, string? targetDatabaseName, IServiceProvider serviceProvider, CancellationToken ct) 
         where TResource : IResourceWithDacpac
     {

tests/CommunityToolkit.Aspire.Hosting.SqlDatabaseProjects.Tests/AddSqlProjectTests.cs

@@ -110,4 +110,25 @@ public void WithReference_AddsRequiredServices()
         Assert.Single(app.Services.GetServices<SqlProjectPublishService>());
         Assert.Single(app.Services.GetServices<IDacpacDeployer>());
     }
+
+    [Fact]
+    public void AddSqlProject_WithExplicitStart()
+    {
+        // Arrange
+        var appBuilder = DistributedApplication.CreateBuilder();
+        var targetDatabase = appBuilder.AddSqlServer("sql").AddDatabase("test");
+        appBuilder.AddSqlProject<TestProject>("MySqlProject")
+            .WithReference(targetDatabase)
+            .WithExplicitStart();
+
+        // Act
+        using var app = appBuilder.Build();
+        var appModel = app.Services.GetRequiredService<DistributedApplicationModel>();
+
+        // Assert
+        var sqlProjectResource = Assert.Single(appModel.Resources.OfType<SqlProjectResource>());
+        Assert.Equal("MySqlProject", sqlProjectResource.Name);
+
+        Assert.True(sqlProjectResource.HasAnnotationOfType<ExplicitStartupAnnotation>());
+    }
 }