Add runtime migration creation and application

src/EFCore.Design/Design/DesignTimeServiceCollectionExtensions.cs

@@ -2,6 +2,8 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using Microsoft.EntityFrameworkCore.Design.Internal;
+using Microsoft.EntityFrameworkCore.Migrations.Design;
+using Microsoft.EntityFrameworkCore.Migrations.Design.Internal;
 using Microsoft.EntityFrameworkCore.Migrations.Internal;
 using Microsoft.EntityFrameworkCore.Query.Internal;
 using Microsoft.EntityFrameworkCore.Scaffolding.Internal;
@@ -65,7 +67,8 @@ public static IServiceCollection AddEntityFrameworkDesignTimeServices(
                 .TryAddScoped<IReverseEngineerScaffolder, ReverseEngineerScaffolder>()
                 .TryAddScoped<MigrationsScaffolderDependencies, MigrationsScaffolderDependencies>()
                 .TryAddScoped<IMigrationsScaffolder, MigrationsScaffolder>()
-                .TryAddScoped<ISnapshotModelProcessor, SnapshotModelProcessor>());
+                .TryAddScoped<ISnapshotModelProcessor, SnapshotModelProcessor>()
+                .TryAddSingleton<IMigrationCompiler, CSharpMigrationCompiler>());
 
         var loggerFactory = new LoggerFactory(
             [new OperationLoggerProvider(reporter)], new LoggerFilterOptions { MinLevel = LogLevel.Debug });
@@ -100,6 +103,7 @@ public static IServiceCollection AddDbContextDesignTimeServices(
             .TryAdd(_ => context.GetService<IMigrationsModelDiffer>())
             .TryAdd(_ => context.GetService<IMigrator>())
             .TryAdd(_ => context.GetService<IDesignTimeModel>().Model);
+
         return services;
     }
 }

src/EFCore.Design/Design/Internal/MigrationsOperations.cs

@@ -1,7 +1,10 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Diagnostics.CodeAnalysis;
 using Microsoft.EntityFrameworkCore.Internal;
+using Microsoft.EntityFrameworkCore.Migrations.Design;
+using Microsoft.EntityFrameworkCore.Migrations.Design.Internal;
 
 namespace Microsoft.EntityFrameworkCore.Design.Internal;
 
@@ -70,31 +73,8 @@ public virtual MigrationFiles AddMigration(
         string? @namespace,
         bool dryRun)
     {
-        var invalidPathChars = Path.GetInvalidFileNameChars();
-        if (name.Any(c => invalidPathChars.Contains(c)))
-        {
-            throw new OperationException(
-                DesignStrings.BadMigrationName(name, string.Join("','", invalidPathChars)));
-        }
-
-        if (outputDir != null)
-        {
-            outputDir = Path.GetFullPath(Path.Combine(_projectDir, outputDir));
-        }
-
-        var subNamespace = SubnamespaceFromOutputPath(outputDir);
-
         using var context = _contextOperations.CreateContext(contextType);
-        var contextClassName = context.GetType().Name;
-        if (string.Equals(name, contextClassName, StringComparison.Ordinal))
-        {
-            throw new OperationException(
-                DesignStrings.ConflictingContextAndMigrationName(name));
-        }
-
-        var services = _servicesBuilder.Build(context);
-        EnsureServices(services);
-        EnsureMigrationsAssembly(services);
+        var (resolvedOutputDir, subNamespace, services) = PrepareForMigration(name, outputDir, context);
 
         using var scope = services.CreateScope();
         var scaffolder = scope.ServiceProvider.GetRequiredService<IMigrationsScaffolder>();
@@ -103,7 +83,7 @@ public virtual MigrationFiles AddMigration(
                 // TODO: Honor _nullable (issue #18950)
                 ? scaffolder.ScaffoldMigration(name, _rootNamespace ?? string.Empty, subNamespace, _language, dryRun)
                 : scaffolder.ScaffoldMigration(name, null, @namespace, _language, dryRun);
-        return scaffolder.Save(_projectDir, migration, outputDir, dryRun);
+        return scaffolder.Save(_projectDir, migration, resolvedOutputDir, dryRun);
     }
 
     // if outputDir is a subfolder of projectDir, then use each subfolder as a sub-namespace
@@ -272,6 +252,111 @@ public virtual void HasPendingModelChanges(string? contextType)
         _reporter.WriteInformation(DesignStrings.NoPendingModelChanges);
     }
 
+    /// <summary>
+    ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
+    ///     the same compatibility standards as public APIs. It may be changed or removed without notice in
+    ///     any release. You should only use it directly in your code with extreme caution and knowing that
+    ///     doing so can result in application failures when updating to a new Entity Framework Core release.
+    /// </summary>
+    [RequiresDynamicCode("Runtime migration compilation requires dynamic code generation.")]
+    public virtual MigrationFiles AddAndApplyMigration(
+        string name,
+        string? outputDir,
+        string? contextType,
+        string? @namespace,
+        string? connectionString)
+    {
+        using var context = _contextOperations.CreateContext(contextType);
+        var (resolvedOutputDir, subNamespace, services) = PrepareForMigration(name, outputDir, context);
+
+        if (connectionString != null)
+        {
+            context.Database.SetConnectionString(connectionString);
+        }
+
+        using var scope = services.CreateScope();
+        var migrator = scope.ServiceProvider.GetRequiredService<IMigrator>();
+        var scaffolder = scope.ServiceProvider.GetRequiredService<IMigrationsScaffolder>();
+        var compiler = scope.ServiceProvider.GetRequiredService<IMigrationCompiler>();
+        var migrationsAssembly = scope.ServiceProvider.GetRequiredService<IMigrationsAssembly>();
+
+        if (!migrator.HasPendingModelChanges())
+        {
+            _reporter.WriteInformation(DesignStrings.NoPendingModelChanges);
+            migrator.Migrate(null);
+            _reporter.WriteInformation(DesignStrings.Done);
+            // Return empty MigrationFiles to indicate no migration was created.
+            // When serialized to JSON (with --json), all file path properties will be null.
+            return new MigrationFiles();
+        }
+
+        _reporter.WriteInformation(DesignStrings.CreatingAndApplyingMigration(name));
+
+        var migration =
+            string.IsNullOrEmpty(@namespace)
+                ? scaffolder.ScaffoldMigration(name, _rootNamespace ?? string.Empty, subNamespace, _language, dryRun: true)
+                : scaffolder.ScaffoldMigration(name, null, @namespace, _language, dryRun: true);
+
+        MigrationFiles? files = null;
+        try
+        {
+            files = scaffolder.Save(_projectDir, migration, resolvedOutputDir, dryRun: false);
+
+            var compiledAssembly = compiler.CompileMigration(migration, context.GetType());
+            migrationsAssembly.AddMigrations(compiledAssembly);
+
+            migrator.Migrate(migration.MigrationId);
+
+            _reporter.WriteInformation(DesignStrings.MigrationCreatedAndApplied(migration.MigrationId));
+
+            return files;
+        }
+        catch (Exception ex)
+        {
+            throw new OperationException(
+                DesignStrings.AddAndApplyMigrationFailed(name, ex.Message), ex);
+        }
+    }
+
+    /// <summary>
+    ///     Prepares common resources for migration operations.
+    /// </summary>
+    private (string? outputDir, string? subNamespace, IServiceProvider services)
+        PrepareForMigration(string name, string? outputDir, DbContext context)
+    {
+        if (string.IsNullOrWhiteSpace(name))
+        {
+            throw new OperationException(DesignStrings.MigrationNameRequired);
+        }
+
+        var invalidPathChars = Path.GetInvalidFileNameChars();
+        if (name.Any(c => invalidPathChars.Contains(c)))
+        {
+            throw new OperationException(
+                DesignStrings.BadMigrationName(name, string.Join("','", invalidPathChars)));
+        }
+
+        if (outputDir != null)
+        {
+            outputDir = Path.GetFullPath(Path.Combine(_projectDir, outputDir));
+        }
+
+        var subNamespace = SubnamespaceFromOutputPath(outputDir);
+
+        var contextClassName = context.GetType().Name;
+        if (string.Equals(name, contextClassName, StringComparison.Ordinal))
+        {
+            throw new OperationException(
+                DesignStrings.ConflictingContextAndMigrationName(name));
+        }
+
+        var services = _servicesBuilder.Build(context);
+        EnsureServices(services);
+        EnsureMigrationsAssembly(services);
+
+        return (outputDir, subNamespace, services);
+    }
+
     private static void EnsureServices(IServiceProvider services)
     {
         var migrator = services.GetService<IMigrator>();

src/EFCore.Design/Design/OperationExecutor.cs

@@ -293,6 +293,64 @@ private void UpdateDatabaseImpl(
         string? contextType)
         => MigrationsOperations.UpdateDatabase(targetMigration, connectionString, contextType);
 
+    /// <summary>
+    ///     Represents an operation to add and apply a new migration in one step.
+    /// </summary>
+    public class AddAndApplyMigration : OperationBase
+    {
+        /// <summary>
+        ///     Initializes a new instance of the <see cref="AddAndApplyMigration" /> class.
+        /// </summary>
+        /// <remarks>
+        ///     <para>The arguments supported by <paramref name="args" /> are:</para>
+        ///     <para><c>name</c>--The name of the migration.</para>
+        ///     <para><c>outputDir</c>--The directory to put files in. Paths are relative to the project directory.</para>
+        ///     <para><c>contextType</c>--The <see cref="DbContext" /> to use.</para>
+        ///     <para><c>namespace</c>--The namespace to use for the migration.</para>
+        ///     <para>
+        ///         <c>connectionString</c>--The connection string to the database. Defaults to the one specified in
+        ///         <see cref="O:Microsoft.Extensions.DependencyInjection.EntityFrameworkServiceCollectionExtensions.AddDbContext" /> or
+        ///         <see cref="DbContext.OnConfiguring" />.
+        ///     </para>
+        /// </remarks>
+        /// <param name="executor">The operation executor.</param>
+        /// <param name="resultHandler">The <see cref="IOperationResultHandler" />.</param>
+        /// <param name="args">The operation arguments.</param>
+        public AddAndApplyMigration(
+            OperationExecutor executor,
+            IOperationResultHandler resultHandler,
+            IDictionary args)
+            : base(resultHandler)
+        {
+            Check.NotNull(executor);
+            Check.NotNull(args);
+
+            var name = (string)args["name"]!;
+            var outputDir = (string?)args["outputDir"];
+            var contextType = (string?)args["contextType"];
+            var @namespace = (string?)args["namespace"];
+            var connectionString = (string?)args["connectionString"];
+
+            Execute(() => executor.AddAndApplyMigrationImpl(name, outputDir, contextType, @namespace, connectionString));
+        }
+    }
+
+    private IDictionary AddAndApplyMigrationImpl(
+        string name,
+        string? outputDir,
+        string? contextType,
+        string? @namespace,
+        string? connectionString)
+    {
+        var files = MigrationsOperations.AddAndApplyMigration(name, outputDir, contextType, @namespace, connectionString);
+        return new Hashtable
+        {
+            ["MigrationFile"] = files.MigrationFile,
+            ["MetadataFile"] = files.MetadataFile,
+            ["SnapshotFile"] = files.SnapshotFile
+        };
+    }
+
     /// <summary>
     ///     Represents an operation to generate a SQL script from migrations.
     /// </summary>