Add dotnet-ef JSON config defaults and validation features (#37966)

Add .config/dotnet-ef.json discovery from current directory up to repo root and apply config values for project, startup project, framework, configuration, and context when CLI options are not explicitly provided.

Introduce resource-backed validation and error handling for invalid JSON, unsupported/unknown properties, invalid value types, and unreadable files.

Add dotnet-ef tests for config discovery/precedence, path resolution, argument propagation, and failure scenarios.

Impact: users can set consistent dotnet-ef defaults in source-controlled config with existing CLI precedence preserved, reducing repetitive command arguments without breaking current behavior.

Fixes #35231

Author: IMZihad21

src/dotnet-ef/DotNetEfConfigLoader.cs

@@ -0,0 +1,144 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Text.Json;
+using Microsoft.EntityFrameworkCore.Tools.Properties;
+
+namespace Microsoft.EntityFrameworkCore.Tools;
+
+internal sealed record DotNetEfConfig(
+    string Path,
+    string? Project,
+    string? StartupProject,
+    string? Context,
+    string? Framework,
+    string? Configuration,
+    string? Runtime,
+    bool? Verbose,
+    bool? NoColor,
+    bool? PrefixOutput);
+
+internal static class DotNetEfConfigLoader
+{
+    private const string ConfigDirectoryName = ".config";
+    private const string ConfigFileName = "dotnet-ef.json";
+
+    public static DotNetEfConfig? Load(string currentDirectory)
+    {
+        var configPath = Discover(currentDirectory);
+        return configPath == null ? null : LoadFile(configPath);
+    }
+
+    private static string? Discover(string currentDirectory)
+    {
+        var directory = new DirectoryInfo(Path.GetFullPath(currentDirectory));
+
+        while (directory != null)
+        {
+            var configPath = Path.Combine(directory.FullName, ConfigDirectoryName, ConfigFileName);
+            if (File.Exists(configPath))
+            {
+                return configPath;
+            }
+
+            directory = directory.Parent;
+        }
+
+        return null;
+    }
+
+    internal static DotNetEfConfig LoadFile(string configPath)
+    {
+        var fullPath = Path.GetFullPath(configPath);
+
+        JsonDocument document;
+        try
+        {
+            using var stream = File.OpenRead(fullPath);
+            document = JsonDocument.Parse(stream);
+        }
+        catch (Exception exception) when (exception is IOException or UnauthorizedAccessException)
+        {
+            throw new CommandException(Resources.DotNetEfConfigReadFailed(fullPath, exception.Message), exception);
+        }
+        catch (JsonException exception)
+        {
+            throw new CommandException(Resources.DotNetEfConfigInvalidJson(fullPath, exception.Message), exception);
+        }
+
+        using (document)
+        {
+            if (document.RootElement.ValueKind != JsonValueKind.Object)
+            {
+                throw new CommandException(Resources.DotNetEfConfigInvalidRoot(fullPath));
+            }
+
+            var configDirectory = Directory.GetParent(Path.GetDirectoryName(fullPath)!)!.FullName;
+            string? project = null;
+            string? startupProject = null;
+            string? context = null;
+            string? framework = null;
+            string? configuration = null;
+            string? runtime = null;
+            bool? verbose = null;
+            bool? noColor = null;
+            bool? prefixOutput = null;
+
+            foreach (var property in document.RootElement.EnumerateObject())
+            {
+                switch (property.Name)
+                {
+                    case "project":
+                        project = ResolvePath(configDirectory, ValidateValue(fullPath, property));
+                        break;
+                    case "startupProject":
+                        startupProject = ResolvePath(configDirectory, ValidateValue(fullPath, property));
+                        break;
+                    case "context":
+                        context = ValidateValue(fullPath, property);
+                        break;
+                    case "framework":
+                        framework = ValidateValue(fullPath, property);
+                        break;
+                    case "configuration":
+                        configuration = ValidateValue(fullPath, property);
+                        break;
+                    case "runtime":
+                        runtime = ValidateValue(fullPath, property);
+                        break;
+                    case "verbose":
+                        verbose = ValidateBoolValue(fullPath, property);
+                        break;
+                    case "noColor":
+                        noColor = ValidateBoolValue(fullPath, property);
+                        break;
+                    case "prefixOutput":
+                        prefixOutput = ValidateBoolValue(fullPath, property);
+                        break;
+                    default:
+                        throw new CommandException(Resources.DotNetEfConfigUnknownProperty(fullPath, property.Name));
+                }
+            }
+
+            return new DotNetEfConfig(fullPath, project, startupProject, context, framework, configuration, runtime, verbose, noColor, prefixOutput);
+        }
+    }
+
+    private static string ValidateValue(string fullPath, JsonProperty property)
+        => property.Value.ValueKind == JsonValueKind.String
+            && !string.IsNullOrWhiteSpace(property.Value.GetString())
+                ? property.Value.GetString()!
+                : throw new CommandException(Resources.DotNetEfConfigInvalidValue(fullPath, property.Name));
+
+    private static bool ValidateBoolValue(string fullPath, JsonProperty property)
+        => property.Value.ValueKind == JsonValueKind.True || property.Value.ValueKind == JsonValueKind.False
+            ? property.Value.GetBoolean()
+            : throw new CommandException(Resources.DotNetEfConfigInvalidBoolValue(fullPath, property.Name));
+
+
+
+    private static string ResolvePath(string configDirectory, string path)
+        => Path.IsPathRooted(path)
+            ? path
+            : Path.GetFullPath(Path.Combine(configDirectory, path));
+}

src/dotnet-ef/Properties/Resources.Designer.cs

@@ -192,6 +192,24 @@
   <data name="DotnetEfFullName" xml:space="preserve">
     <value>Entity Framework Core .NET Command-line Tools</value>
   </data>
+  <data name="DotNetEfConfigInvalidJson" xml:space="preserve">
+    <value>Unable to read '{configFile}'. Fix the JSON and try again. {details}</value>
+  </data>
+  <data name="DotNetEfConfigInvalidRoot" xml:space="preserve">
+    <value>Unable to read '{configFile}'. The file must contain a JSON object.</value>
+  </data>
+  <data name="DotNetEfConfigInvalidValue" xml:space="preserve">
+    <value>Unable to read '{configFile}'. The '{propertyName}' property must be a non-empty JSON string.</value>
+  </data>
+  <data name="DotNetEfConfigInvalidBoolValue" xml:space="preserve">
+    <value>Unable to read '{configFile}'. The '{propertyName}' property must be a boolean.</value>
+  </data>
+  <data name="DotNetEfConfigReadFailed" xml:space="preserve">
+    <value>Unable to read '{configFile}'. Ensure the file is accessible and try again. {details}</value>
+  </data>
+  <data name="DotNetEfConfigUnknownProperty" xml:space="preserve">
+    <value>Unable to read '{configFile}'. Remove the unsupported '{propertyName}' property.</value>
+  </data>
   <data name="EFFullName" xml:space="preserve">
     <value>Entity Framework Core Command-line Tools</value>
   </data>

src/dotnet-ef/Properties/Resources.resx

@@ -59,31 +59,46 @@ protected override int Execute(string[] _)
             return ShowHelp(_help.HasValue(), commands);
         }
 
+        var config = DotNetEfConfigLoader.Load(Directory.GetCurrentDirectory());
+        var projectPath = _project!.Value() ?? config?.Project;
+        var startupProjectPath = _startupProject!.Value() ?? config?.StartupProject;
+        var framework = _framework!.Value() ?? config?.Framework;
+        var configuration = _configuration!.Value() ?? config?.Configuration;
+        var runtime = _runtime!.Value() ?? config?.Runtime;
+        var context = ResolveContext(_args!, config?.Context);
+        var remainingArguments = CreateRemainingArguments(_args!, context);
+
+        if (config?.Verbose == true && !ContainsOption(_args!, "-v", "--verbose"))
+            Reporter.IsVerbose = true;
+
+        if (config?.NoColor == true && !ContainsOption(_args!, "--no-color"))
+            Reporter.NoColor = true;
+
+        if (config?.PrefixOutput == true && !ContainsOption(_args!, "--prefix-output"))
+            Reporter.PrefixOutput = true;
+
         var (projectFile, startupProjectFile) = ResolveProjects(
-            _project!.Value(),
-            _startupProject!.Value());
+            projectPath,
+            startupProjectPath);
 
         Reporter.WriteVerbose(Resources.UsingProject(projectFile));
         Reporter.WriteVerbose(Resources.UsingStartupProject(startupProjectFile));
 
         var project = Project.FromFile(
             projectFile,
-            _framework!.Value(),
-            _configuration!.Value(),
-            _runtime!.Value());
+            framework,
+            configuration,
+            runtime);
         var startupProject = Project.FromFile(
             startupProjectFile,
-            _framework!.Value(),
-            _configuration!.Value(),
-            _runtime!.Value());
+            framework,
+            configuration,
+            runtime);
 
         if (!_noBuild!.HasValue())
         {
             Reporter.WriteInformation(Resources.BuildStarted);
-            var skipOptimization = _args!.Count > 2
-                && _args[0] == "dbcontext"
-                && _args[1] == "optimize"
-                && !_args.Any(a => a == "--no-scaffold");
+            var skipOptimization = ShouldSkipOptimization(_args!);
             startupProject.Build(skipOptimization ? ["/p:EFScaffoldModelStage=none", "/p:EFPrecompileQueriesStage=none"] : null);
             Reporter.WriteInformation(Resources.BuildSucceeded);
         }
@@ -169,7 +184,7 @@ protected override int Execute(string[] _)
                 Resources.UnsupportedFramework(startupProject.ProjectName, targetFramework.Identifier));
         }
 
-        args.AddRange(_args!);
+        args.AddRange(remainingArguments);
         args.Add("--assembly");
         args.Add(targetPath);
         args.Add("--project");
@@ -194,10 +209,10 @@ protected override int Execute(string[] _)
             args.Add(designAssembly);
         }
 
-        if (_configuration.HasValue())
+        if (configuration != null)
         {
             args.Add("--configuration");
-            args.Add(_configuration.Value()!);
+            args.Add(configuration);
         }
 
         if (string.Equals(project.Nullable, "enable", StringComparison.OrdinalIgnoreCase)
@@ -312,6 +327,61 @@ private static List<string> ResolveProjects(string? path)
         return projectFiles;
     }
 
+    internal static string? ResolveContext(IList<string> args, string? configValue)
+        => configValue != null
+            && AppliesToContext(args)
+            && !ContainsOption(args, "-c", "--context")
+                ? configValue
+                : null;
+
+    internal static List<string> CreateRemainingArguments(
+        IList<string> args,
+        string? context)
+    {
+        var remainingArguments = new List<string>(args);
+
+        if (context != null)
+        {
+            remainingArguments.Add("--context");
+            remainingArguments.Add(context);
+        }
+
+        return remainingArguments;
+    }
+
+    private static bool AppliesToContext(IList<string> args)
+        => args.Count >= 2
+            && (args[0], args[1]) switch
+            {
+                ("database", "drop") => true,
+                ("database", "update") => true,
+                ("dbcontext", "info") => true,
+                ("dbcontext", "optimize") => true,
+                ("dbcontext", "script") => true,
+                ("migrations", "add") => true,
+                ("migrations", "bundle") => true,
+                ("migrations", "has-pending-model-changes") => true,
+                ("migrations", "list") => true,
+                ("migrations", "remove") => true,
+                ("migrations", "script") => true,
+                _ => false
+            };
+
+    private static bool ContainsOption(
+        IList<string> args,
+        params string[] names)
+        => args.Any(
+            argument => names.Any(
+                name => string.Equals(argument, name, StringComparison.Ordinal)
+                    || argument.StartsWith(name + "=", StringComparison.Ordinal)
+                    || argument.StartsWith(name + ":", StringComparison.Ordinal)));
+
+    internal static bool ShouldSkipOptimization(IList<string> args)
+        => args.Count > 2
+            && args[0] == "dbcontext"
+            && args[1] == "optimize"
+            && !args.Any(a => a == "--no-scaffold");
+
     private static string GetVersion()
         => typeof(RootCommand).Assembly.GetCustomAttribute<AssemblyInformationalVersionAttribute>()!
             .InformationalVersion;