dependabot-nuget 0.288.0 → 0.290.0

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Discover/DiscoveryWorker.cs

@@ -18,7 +18,7 @@ public partial class DiscoveryWorker : IDiscoveryWorker
 
     private readonly ExperimentsManager _experimentsManager;
     private readonly ILogger _logger;
-    private readonly HashSet<string> _processedProjectPaths = new(StringComparer.OrdinalIgnoreCase); private readonly HashSet<string> _restoredMSBuildSdks = new(StringComparer.OrdinalIgnoreCase);
+    private readonly HashSet<string> _processedProjectPaths = new(StringComparer.Ordinal); private readonly HashSet<string> _restoredMSBuildSdks = new(StringComparer.OrdinalIgnoreCase);
 
     internal static readonly JsonSerializerOptions SerializerOptions = new()
     {
@@ -54,7 +54,6 @@ public partial class DiscoveryWorker : IDiscoveryWorker
                 ErrorDetails = "(" + string.Join("|", NuGetContext.GetPackageSourceUrls(PathHelper.JoinPath(repoRootPath, workspacePath))) + ")",
                 Path = workspacePath,
                 Projects = [],
-                ImportedFiles = [],
             };
         }
 
@@ -83,7 +82,7 @@ public partial class DiscoveryWorker : IDiscoveryWorker
 
         if (Directory.Exists(workspacePath))
         {
-            _logger.Log($"Discovering build files in workspace [{workspacePath}].");
+            _logger.Info($"Discovering build files in workspace [{workspacePath}].");
 
             dotNetToolsJsonDiscovery = DotNetToolsJsonDiscovery.Discover(repoRootPath, workspacePath, _logger);
             globalJsonDiscovery = GlobalJsonDiscovery.Discover(repoRootPath, workspacePath, _logger);
@@ -98,18 +97,7 @@ public partial class DiscoveryWorker : IDiscoveryWorker
         }
         else
         {
-            _logger.Log($"Workspace path [{workspacePath}] does not exist.");
-        }
-
-        var importedFiles = new HashSet<string>(PathComparer.Instance);
-        foreach (var project in projectResults)
-        {
-            // imported files are relative to the project and need to be converted to be relative to the repo root
-            var repoRootRelativeImportedFiles = project.ImportedFiles
-                .Select(p => Path.Join(Path.GetDirectoryName(project.FilePath) ?? "", p))
-                .Select(p => p.NormalizePathToUnix().NormalizeUnixPathParts())
-                .ToArray();
-            importedFiles.AddRange(repoRootRelativeImportedFiles);
+            _logger.Info($"Workspace path [{workspacePath}] does not exist.");
         }
 
         result = new WorkspaceDiscoveryResult
@@ -118,10 +106,9 @@ public partial class DiscoveryWorker : IDiscoveryWorker
             DotNetToolsJson = dotNetToolsJsonDiscovery,
             GlobalJson = globalJsonDiscovery,
             Projects = projectResults.OrderBy(p => p.FilePath).ToImmutableArray(),
-            ImportedFiles = importedFiles.ToImmutableArray(),
         };
 
-        _logger.Log("Discovery complete.");
+        _logger.Info("Discovery complete.");
         _processedProjectPaths.Clear();
 
         return result;
@@ -148,19 +135,19 @@ public partial class DiscoveryWorker : IDiscoveryWorker
 
         _restoredMSBuildSdks.AddRange(keys);
 
-        _logger.Log($"  Restoring MSBuild SDKs: {string.Join(", ", keys)}");
+        _logger.Info($"  Restoring MSBuild SDKs: {string.Join(", ", keys)}");
 
         return await NuGetHelper.DownloadNuGetPackagesAsync(repoRootPath, workspacePath, msbuildSdks, logger);
     }
 
     private async Task<ImmutableArray<ProjectDiscoveryResult>> RunForDirectoryAsnyc(string repoRootPath, string workspacePath)
     {
-        _logger.Log($"  Discovering projects beneath [{Path.GetRelativePath(repoRootPath, workspacePath)}].");
+        _logger.Info($"  Discovering projects beneath [{Path.GetRelativePath(repoRootPath, workspacePath)}].");
         var entryPoints = FindEntryPoints(workspacePath);
         var projects = ExpandEntryPointsIntoProjects(entryPoints);
         if (projects.IsEmpty)
         {
-            _logger.Log("  No project files found.");
+            _logger.Info("  No project files found.");
             return [];
         }
 
@@ -277,74 +264,81 @@ public partial class DiscoveryWorker : IDiscoveryWorker
 
     private async Task<ImmutableArray<ProjectDiscoveryResult>> RunForProjectPathsAsync(string repoRootPath, string workspacePath, IEnumerable<string> projectPaths)
     {
-        var results = new Dictionary<string, ProjectDiscoveryResult>(StringComparer.OrdinalIgnoreCase);
+        var results = new Dictionary<string, ProjectDiscoveryResult>(StringComparer.Ordinal);
         foreach (var projectPath in projectPaths)
         {
             // If there is some MSBuild logic that needs to run to fully resolve the path skip the project
             // Ensure file existence is checked case-insensitively
-            var actualProjectPath = PathHelper.ResolveCaseInsensitivePathInsideRepoRoot(projectPath, repoRootPath);
-            if (actualProjectPath == null)
-            {
-                continue;
-            }
+            var actualProjectPaths = PathHelper.ResolveCaseInsensitivePathsInsideRepoRoot(projectPath, repoRootPath);
 
-            if (_processedProjectPaths.Contains(actualProjectPath))
+            if (actualProjectPaths == null)
             {
                 continue;
             }
-            _processedProjectPaths.Add(actualProjectPath);
 
-            var relativeProjectPath = Path.GetRelativePath(workspacePath, actualProjectPath).NormalizePathToUnix();
-            var packagesConfigResult = await PackagesConfigDiscovery.Discover(repoRootPath, workspacePath, actualProjectPath, _logger);
-            var projectResults = await SdkProjectDiscovery.DiscoverAsync(repoRootPath, workspacePath, actualProjectPath, _experimentsManager, _logger);
-
-            // Determine if there were unrestored MSBuildSdks
-            var msbuildSdks = projectResults.SelectMany(p => p.Dependencies.Where(d => d.Type == DependencyType.MSBuildSdk)).ToImmutableArray();
-            if (msbuildSdks.Length > 0)
+            foreach (var actualProjectPath in actualProjectPaths)
             {
-                // If new SDKs were restored, then we need to rerun SdkProjectDiscovery.
-                if (await TryRestoreMSBuildSdksAsync(repoRootPath, workspacePath, msbuildSdks, _logger))
+                if (_processedProjectPaths.Contains(actualProjectPath))
                 {
-                    projectResults = await SdkProjectDiscovery.DiscoverAsync(repoRootPath, workspacePath, actualProjectPath, _experimentsManager, _logger);
+                    continue;
                 }
-            }
 
-            foreach (var projectResult in projectResults)
-            {
-                if (results.ContainsKey(projectResult.FilePath))
+                _processedProjectPaths.Add(actualProjectPath);
+
+                var relativeProjectPath = Path.GetRelativePath(workspacePath, actualProjectPath).NormalizePathToUnix();
+                var packagesConfigResult = await PackagesConfigDiscovery.Discover(repoRootPath, workspacePath, actualProjectPath, _logger);
+                var projectResults = await SdkProjectDiscovery.DiscoverAsync(repoRootPath, workspacePath, actualProjectPath, _experimentsManager, _logger);
+
+                // Determine if there were unrestored MSBuildSdks
+                var msbuildSdks = projectResults.SelectMany(p => p.Dependencies.Where(d => d.Type == DependencyType.MSBuildSdk)).ToImmutableArray();
+                if (msbuildSdks.Length > 0)
                 {
-                    continue;
+                    // If new SDKs were restored, then we need to rerun SdkProjectDiscovery.
+                    if (await TryRestoreMSBuildSdksAsync(repoRootPath, workspacePath, msbuildSdks, _logger))
+                    {
+                        projectResults = await SdkProjectDiscovery.DiscoverAsync(repoRootPath, workspacePath, actualProjectPath, _experimentsManager, _logger);
+                    }
                 }
 
-                // If we had packages.config dependencies, merge them with the project dependencies
-                if (projectResult.FilePath == relativeProjectPath && packagesConfigResult is not null)
+                foreach (var projectResult in projectResults)
                 {
-                    var packagesConfigDependencies = packagesConfigResult.Dependencies
-                        .Select(d => d with { TargetFrameworks = projectResult.TargetFrameworks })
-                        .ToImmutableArray();
+                    if (results.ContainsKey(projectResult.FilePath))
+                    {
+                        continue;
+                    }
 
-                    results[projectResult.FilePath] = projectResult with
+                    // If we had packages.config dependencies, merge them with the project dependencies
+                    if (projectResult.FilePath == relativeProjectPath && packagesConfigResult is not null)
                     {
-                        Dependencies = [.. projectResult.Dependencies, .. packagesConfigDependencies],
-                    };
-                }
-                else
-                {
-                    results[projectResult.FilePath] = projectResult;
+                        var packagesConfigDependencies = packagesConfigResult.Dependencies
+                            .Select(d => d with { TargetFrameworks = projectResult.TargetFrameworks })
+                            .ToImmutableArray();
+
+                        results[projectResult.FilePath] = projectResult with
+                        {
+                            Dependencies = [.. projectResult.Dependencies, .. packagesConfigDependencies],
+                        };
+                    }
+                    else
+                    {
+                        results[projectResult.FilePath] = projectResult;
+                    }
                 }
-            }
 
-            if (!results.ContainsKey(relativeProjectPath) &&
-                packagesConfigResult is not null &&
-                packagesConfigResult.Dependencies.Length > 0)
-            {
-                // project contained only packages.config dependencies
-                results[relativeProjectPath] = new ProjectDiscoveryResult()
+                if (!results.ContainsKey(relativeProjectPath) &&
+                    packagesConfigResult is not null &&
+                    packagesConfigResult.Dependencies.Length > 0)
                 {
-                    FilePath = relativeProjectPath,
-                    Dependencies = packagesConfigResult.Dependencies,
-                    TargetFrameworks = packagesConfigResult.TargetFrameworks,
-                };
+                    // project contained only packages.config dependencies
+                    results[relativeProjectPath] = new ProjectDiscoveryResult()
+                    {
+                        FilePath = relativeProjectPath,
+                        Dependencies = packagesConfigResult.Dependencies,
+                        TargetFrameworks = packagesConfigResult.TargetFrameworks,
+                        ImportedFiles = [], // no imported files resolved for packages.config scenarios
+                        AdditionalFiles = packagesConfigResult.AdditionalFiles,
+                    };
+                }
             }
         }
 

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Discover/DotNetToolsJsonDiscovery.cs

@@ -8,13 +8,13 @@ internal static class DotNetToolsJsonDiscovery
     {
         if (!MSBuildHelper.TryGetDotNetToolsJsonPath(repoRootPath, workspacePath, out var dotnetToolsJsonPath))
         {
-            logger.Log("  No dotnet-tools.json file found.");
+            logger.Info("  No dotnet-tools.json file found.");
             return null;
         }
 
         var dotnetToolsJsonFile = DotNetToolsJsonBuildFile.Open(workspacePath, dotnetToolsJsonPath, logger);
 
-        logger.Log($"  Discovered [{dotnetToolsJsonFile.RelativePath}] file.");
+        logger.Info($"  Discovered [{dotnetToolsJsonFile.RelativePath}] file.");
 
         var dependencies = BuildFile.GetDependencies(dotnetToolsJsonFile)
             .OrderBy(d => d.Name)

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Discover/GlobalJsonDiscovery.cs

@@ -8,13 +8,13 @@ internal static class GlobalJsonDiscovery
     {
         if (!MSBuildHelper.TryGetGlobalJsonPath(repoRootPath, workspacePath, out var globalJsonPath))
         {
-            logger.Log("  No global.json file found.");
+            logger.Info("  No global.json file found.");
             return null;
         }
 
         var globalJsonFile = GlobalJsonBuildFile.Open(workspacePath, globalJsonPath, logger);
 
-        logger.Log($"  Discovered [{globalJsonFile.RelativePath}] file.");
+        logger.Info($"  Discovered [{globalJsonFile.RelativePath}] file.");
 
         var dependencies = BuildFile.GetDependencies(globalJsonFile)
             .OrderBy(d => d.Name)

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Discover/PackagesConfigDiscovery.cs

@@ -1,20 +1,26 @@
 using System.Collections.Immutable;
 
+using NuGetUpdater.Core.Utilities;
+
 namespace NuGetUpdater.Core.Discover;
 
 internal static class PackagesConfigDiscovery
 {
     public static async Task<PackagesConfigDiscoveryResult?> Discover(string repoRootPath, string workspacePath, string projectPath, ILogger logger)
     {
-        if (!NuGetHelper.TryGetPackagesConfigFile(projectPath, out var packagesConfigPath))
+        var projectDirectory = Path.GetDirectoryName(projectPath)!;
+        var additionalFiles = ProjectHelper.GetAllAdditionalFilesFromProject(projectPath, ProjectHelper.PathFormat.Full);
+        var packagesConfigPath = additionalFiles.FirstOrDefault(p => Path.GetFileName(p).Equals(ProjectHelper.PackagesConfigFileName, StringComparison.Ordinal));
+
+        if (packagesConfigPath is null)
         {
-            logger.Log("  No packages.config file found.");
+            logger.Info("  No packages.config file found.");
             return null;
         }
 
         var packagesConfigFile = PackagesConfigBuildFile.Open(workspacePath, packagesConfigPath);
 
-        logger.Log($"  Discovered [{packagesConfigFile.RelativePath}] file.");
+        logger.Info($"  Discovered [{packagesConfigFile.RelativePath}] file.");
 
         var dependencies = BuildFile.GetDependencies(packagesConfigFile)
             .OrderBy(d => d.Name)
@@ -23,11 +29,13 @@ internal static class PackagesConfigDiscovery
         // generate `$(TargetFramework)` via MSBuild
         var tfms = await MSBuildHelper.GetTargetFrameworkValuesFromProject(repoRootPath, projectPath, logger);
 
+        var additionalFilesRelative = additionalFiles.Select(p => Path.GetRelativePath(projectDirectory, p).NormalizePathToUnix()).ToImmutableArray();
         return new()
         {
             FilePath = packagesConfigFile.RelativePath,
             Dependencies = dependencies.Select(d => d with { TargetFrameworks = tfms }).ToImmutableArray(),
             TargetFrameworks = tfms,
+            AdditionalFiles = additionalFilesRelative,
         };
     }
 }

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Discover/PackagesConfigDiscoveryResult.cs

@@ -8,4 +8,5 @@ public sealed record PackagesConfigDiscoveryResult : IDiscoveryResultWithDepende
     public bool IsSuccess { get; init; } = true;
     public required ImmutableArray<Dependency> Dependencies { get; init; }
     public required ImmutableArray<string> TargetFrameworks { get; init; }
+    public required ImmutableArray<string> AdditionalFiles { get; init; }
 }

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Discover/ProjectDiscoveryResult.cs

@@ -11,8 +11,6 @@ public record ProjectDiscoveryResult : IDiscoveryResultWithDependencies
     public ImmutableArray<Property> Properties { get; init; } = [];
     public ImmutableArray<string> TargetFrameworks { get; init; } = [];
     public ImmutableArray<string> ReferencedProjectPaths { get; init; } = [];
-
-    // this is purely for internal record keeping and should not be serialized
-    [JsonIgnore]
-    public ImmutableArray<string> ImportedFiles { get; init; } = [];
+    public required ImmutableArray<string> ImportedFiles { get; init; }
+    public required ImmutableArray<string> AdditionalFiles { get; init; }
 }

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Discover/SdkProjectDiscovery.cs

@@ -36,6 +36,14 @@ internal static class SdkProjectDiscovery
         "NETStandard.Library"
     };
 
+    // these are additional files that are relevant to the project and need to be reported
+    private static readonly HashSet<string> AdditionalFileNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
+    {
+        "packages.config",
+        "app.config",
+        "web.config",
+    };
+
     public static async Task<ImmutableArray<ProjectDiscoveryResult>> DiscoverAsync(string repoRootPath, string workspacePath, string startingProjectPath, ExperimentsManager experimentsManager, ILogger logger)
     {
         if (experimentsManager.UseDirectDiscovery)
@@ -73,6 +81,9 @@ internal static class SdkProjectDiscovery
         Dictionary<string, HashSet<string>> referencedProjects = new(PathComparer.Instance);
         //         projectPath, referencedProjects
 
+        Dictionary<string, HashSet<string>> additionalFiles = new(PathComparer.Instance);
+        //         projectPath, additionalFiles
+
         var tfms = await MSBuildHelper.GetTargetFrameworkValuesFromProject(repoRootPath, startingProjectPath, logger);
         foreach (var tfm in tfms)
         {
@@ -106,7 +117,7 @@ internal static class SdkProjectDiscovery
                 if (exitCode != 0)
                 {
                     // log error, but still try to resolve what we can
-                    logger.Log($"  Error determining dependencies from `{startingProjectPath}`:\nSTDOUT:\n{stdOut}\nSTDERR:\n{stdErr}");
+                    logger.Warn($"  Error determining dependencies from `{startingProjectPath}`:\nSTDOUT:\n{stdOut}\nSTDERR:\n{stdErr}");
                 }
 
                 var buildRoot = BinaryLog.ReadBuild(binLogPath);
@@ -154,17 +165,39 @@ internal static class SdkProjectDiscovery
                         case NamedNode namedNode when namedNode is AddItem or RemoveItem:
                             ProcessResolvedPackageReference(namedNode, packagesPerProject, topLevelPackagesPerProject);
 
-                            // maintain list of project references
-                            if (namedNode is AddItem addItem && addItem.Name == "ProjectReference")
+                            if (namedNode is AddItem addItem)
                             {
-                                var projectEvaluation = GetNearestProjectEvaluation(addItem);
-                                if (projectEvaluation is not null)
+                                // maintain list of project references
+                                if (addItem.Name.Equals("ProjectReference", StringComparison.OrdinalIgnoreCase))
+                                {
+                                    var projectEvaluation = GetNearestProjectEvaluation(addItem);
+                                    if (projectEvaluation is not null)
+                                    {
+                                        foreach (var referencedProject in addItem.Children.OfType<Item>())
+                                        {
+                                            var referencedProjectPaths = referencedProjects.GetOrAdd(projectEvaluation.ProjectFile, () => new(PathComparer.Instance));
+                                            var referencedProjectPath = new FileInfo(Path.Combine(Path.GetDirectoryName(projectEvaluation.ProjectFile)!, referencedProject.Name)).FullName;
+                                            referencedProjectPaths.Add(referencedProjectPath);
+                                        }
+                                    }
+                                }
+
+                                // maintain list of additional files
+                                if (addItem.Name.Equals("None", StringComparison.OrdinalIgnoreCase) ||
+                                    addItem.Name.Equals("Content", StringComparison.OrdinalIgnoreCase))
                                 {
-                                    foreach (var referencedProject in addItem.Children.OfType<Item>())
+                                    var projectEvaluation = GetNearestProjectEvaluation(addItem);
+                                    if (projectEvaluation is not null)
                                     {
-                                        var referencedProjectPaths = referencedProjects.GetOrAdd(projectEvaluation.ProjectFile, () => new(PathComparer.Instance));
-                                        var referencedProjectPath = new FileInfo(Path.Combine(Path.GetDirectoryName(projectEvaluation.ProjectFile)!, referencedProject.Name)).FullName;
-                                        referencedProjectPaths.Add(referencedProjectPath);
+                                        foreach (var additionalItem in addItem.Children.OfType<Item>())
+                                        {
+                                            if (AdditionalFileNames.Contains(additionalItem.Name))
+                                            {
+                                                var additionalFilesForProject = additionalFiles.GetOrAdd(projectEvaluation.ProjectFile, () => new(PathComparer.Instance));
+                                                var additionalFilePath = new FileInfo(Path.Combine(Path.GetDirectoryName(projectEvaluation.ProjectFile)!, additionalItem.Name)).FullName;
+                                                additionalFilesForProject.Add(additionalFilePath);
+                                            }
+                                        }
                                     }
                                 }
                             }
@@ -220,11 +253,18 @@ internal static class SdkProjectDiscovery
                 .Select(pkvp => new Property(pkvp.Key, pkvp.Value, Path.GetRelativePath(repoRootPath, projectPath).NormalizePathToUnix()))
                 .OrderBy(p => p.Name)
                 .ToImmutableArray();
-            var referenced = referencedProjects.GetOrAdd(projectPath, () => new(StringComparer.OrdinalIgnoreCase))
+            var referenced = referencedProjects.GetOrAdd(projectPath, () => new(PathComparer.Instance))
                 .Select(p => Path.GetRelativePath(projectFullDirectory, p).NormalizePathToUnix())
                 .OrderBy(p => p)
                 .ToImmutableArray();
-            var imported = importedFiles.GetOrAdd(projectPath, () => new(StringComparer.OrdinalIgnoreCase))
+            var imported = importedFiles.GetOrAdd(projectPath, () => new(PathComparer.Instance))
+                .Select(p => Path.GetRelativePath(projectFullDirectory, p))
+                .Select(p => p.NormalizePathToUnix())
+                .OrderBy(p => p)
+                .ToImmutableArray();
+            var additionalFromLocation = ProjectHelper.GetAdditionalFilesFromProjectLocation(projectPath, ProjectHelper.PathFormat.Full);
+            var additional = additionalFiles.GetOrAdd(projectPath, () => new(PathComparer.Instance))
+                .Concat(additionalFromLocation)
                 .Select(p => Path.GetRelativePath(projectFullDirectory, p))
                 .Select(p => p.NormalizePathToUnix())
                 .OrderBy(p => p)
@@ -238,6 +278,7 @@ internal static class SdkProjectDiscovery
                 Properties = properties,
                 ReferencedProjectPaths = referenced,
                 ImportedFiles = imported,
+                AdditionalFiles = additional,
             };
         }).ToImmutableArray();
         return projectDiscoveryResults;
@@ -448,6 +489,7 @@ internal static class SdkProjectDiscovery
                         Path.Join(Path.GetDirectoryName(buildFile.Path), "obj"),
                     };
                     var projectDirectory = Path.GetDirectoryName(buildFile.Path)!;
+                    var additionalFiles = ProjectHelper.GetAllAdditionalFilesFromProject(buildFile.Path, ProjectHelper.PathFormat.Relative);
                     results.Add(new()
                     {
                         FilePath = Path.GetRelativePath(workspacePath, buildFile.Path).NormalizePathToUnix(),
@@ -463,6 +505,7 @@ internal static class SdkProjectDiscovery
                             .Where(b => !intermediateDirectories.Any(i => PathHelper.IsFileUnderDirectory(new DirectoryInfo(i), new FileInfo(b.Path))))
                             .Select(b => Path.GetRelativePath(projectDirectory, b.Path).NormalizePathToUnix())
                             .ToImmutableArray(),
+                        AdditionalFiles = additionalFiles,
                     });
                 }
             }

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Discover/WorkspaceDiscoveryResult.cs

@@ -7,7 +7,6 @@ public sealed record WorkspaceDiscoveryResult : NativeResult
     public required string Path { get; init; }
     public bool IsSuccess { get; init; } = true;
     public ImmutableArray<ProjectDiscoveryResult> Projects { get; init; }
-    public ImmutableArray<string> ImportedFiles { get; init; } = [];
     public GlobalJsonDiscoveryResult? GlobalJson { get; init; }
     public DotNetToolsJsonDiscoveryResult? DotNetToolsJson { get; init; }
 }

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/ExperimentsManager.cs

@@ -37,8 +37,7 @@ public record ExperimentsManager
         }
         catch (JsonException ex)
         {
-            // the following message has been specifically designed to match the format of `Dependabot.logger.info(...)` from Ruby
-            logger.Log($"{DateTime.UtcNow:yyyy/MM/dd HH:mm:ss} INFO Error deserializing job file: {ex.ToString()}: {jobFileContent}");
+            logger.Info($"Error deserializing job file: {ex.ToString()}: {jobFileContent}");
             return new ExperimentsManager();
         }
     }

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Files/JsonBuildFile.cs

@@ -39,7 +39,7 @@ internal abstract class JsonBuildFile : BuildFile<string>
             {
                 // We can't police that people have legal JSON files.
                 // If they don't, we just return null.
-                logger.Log($"Failed to parse JSON file: {RelativePath}, got {ex}");
+                logger.Warn($"Failed to parse JSON file: {RelativePath}, got {ex}");
                 FailedToParse = true;
                 return null;
             }

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/FrameworkChecker/CompatabilityChecker.cs

@@ -15,11 +15,11 @@ public class CompatibilityChecker
         var incompatibleFrameworks = projectFrameworks.Where(f => !compatibleFrameworks.Contains(f)).ToArray();
         if (incompatibleFrameworks.Length > 0)
         {
-            logger.Log($"The package is not compatible. Incompatible project frameworks: {string.Join(", ", incompatibleFrameworks.Select(f => f.GetShortFolderName()))}");
+            logger.Warn($"The package is not compatible. Incompatible project frameworks: {string.Join(", ", incompatibleFrameworks.Select(f => f.GetShortFolderName()))}");
             return false;
         }
 
-        logger.Log("The package is compatible.");
+        logger.Info("The package is compatible.");
         return true;
 
         static NuGetFramework ParseFramework(string tfm)

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Run/ApiModel/Advisory.cs

@@ -0,0 +1,13 @@
+using System.Collections.Immutable;
+
+using NuGetUpdater.Core.Analyze;
+
+namespace NuGetUpdater.Core.Run.ApiModel;
+
+public record Advisory
+{
+    public required string DependencyName { get; init; }
+    public ImmutableArray<Requirement>? AffectedVersions { get; init; } = null;
+    public ImmutableArray<Requirement>? PatchedVersions { get; init; } = null;
+    public ImmutableArray<Requirement>? UnaffectedVersions { get; init; } = null;
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Run/ApiModel/AllowedUpdate.cs

@@ -2,5 +2,22 @@ namespace NuGetUpdater.Core.Run.ApiModel;
 
 public sealed record AllowedUpdate
 {
-    public string UpdateType { get; init; } = "all";
+    public DependencyType DependencyType { get; init; } = DependencyType.All;
+    public string? DependencyName { get; init; } = null;
+    public UpdateType UpdateType { get; init; } = UpdateType.All;
+}
+
+public enum DependencyType
+{
+    All,
+    Direct,
+    Indirect,
+    Development,
+    Production,
+}
+
+public enum UpdateType
+{
+    All,
+    Security,
 }

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Run/ApiModel/CommitOptions.cs

@@ -0,0 +1,8 @@
+namespace NuGetUpdater.Core.Run.ApiModel;
+
+public record CommitOptions
+{
+    public string? Prefix { get; init; } = null;
+    public string? PrefixDevelopment { get; init; } = null;
+    public string? IncludeScope { get; init; } = null;
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Run/ApiModel/Condition.cs

@@ -0,0 +1,19 @@
+using System.Text.Json.Serialization;
+
+using NuGetUpdater.Core.Analyze;
+
+namespace NuGetUpdater.Core.Run.ApiModel;
+
+public sealed record Condition
+{
+    [JsonPropertyName("dependency-name")]
+    public required string DependencyName { get; init; }
+    [JsonPropertyName("source")]
+    public string? Source { get; init; } = null;
+    [JsonPropertyName("update-types")]
+    public string[] UpdateTypes { get; init; } = [];
+    [JsonPropertyName("updated-at")]
+    public DateTime? UpdatedAt { get; init; } = null;
+    [JsonPropertyName("version-requirement")]
+    public Requirement? VersionRequirement { get; init; } = null;
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Run/ApiModel/DependencyGroup.cs

@@ -0,0 +1,8 @@
+namespace NuGetUpdater.Core.Run.ApiModel;
+
+public record DependencyGroup
+{
+    public required string Name { get; init; }
+    public string? AppliesTo { get; init; }
+    public Dictionary<string, object> Rules { get; init; } = new();
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Run/ApiModel/GroupPullRequest.cs

@@ -0,0 +1,9 @@
+using System.Collections.Immutable;
+
+namespace NuGetUpdater.Core.Run.ApiModel;
+
+public record GroupPullRequest
+{
+    public required string DependencyGroupName { get; init; }
+    public required ImmutableArray<PullRequest> Dependencies { get; init; }
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Run/ApiModel/Job.cs

@@ -1,25 +1,28 @@
+using System.Collections.Immutable;
 using System.Text.Json;
 using System.Text.Json.Serialization;
 
+using NuGet.Credentials;
+
 namespace NuGetUpdater.Core.Run.ApiModel;
 
 public sealed record Job
 {
     public string PackageManager { get; init; } = "nuget";
-    public AllowedUpdate[]? AllowedUpdates { get; init; } = null;
+    public ImmutableArray<AllowedUpdate> AllowedUpdates { get; init; } = [new AllowedUpdate()];
 
     [JsonConverter(typeof(NullAsBoolConverter))]
     public bool Debug { get; init; } = false;
-    public object[]? DependencyGroups { get; init; } = null;
-    public object[]? Dependencies { get; init; } = null;
+    public ImmutableArray<DependencyGroup> DependencyGroups { get; init; } = [];
+    public ImmutableArray<string>? Dependencies { get; init; } = null;
     public string? DependencyGroupToRefresh { get; init; } = null;
-    public object[]? ExistingPullRequests { get; init; } = null;
-    public object[]? ExistingGroupPullRequests { get; init; } = null;
+    public ImmutableArray<ImmutableArray<PullRequest>> ExistingPullRequests { get; init; } = [];
+    public ImmutableArray<GroupPullRequest> ExistingGroupPullRequests { get; init; } = [];
     public Dictionary<string, object>? Experiments { get; init; } = null;
-    public object[]? IgnoreConditions { get; init; } = null;
+    public Condition[] IgnoreConditions { get; init; } = [];
     public bool LockfileOnly { get; init; } = false;
-    public string? RequirementsUpdateStrategy { get; init; } = null;
-    public object[]? SecurityAdvisories { get; init; } = null;
+    public RequirementsUpdateStrategy? RequirementsUpdateStrategy { get; init; } = null;
+    public ImmutableArray<Advisory> SecurityAdvisories { get; init; } = [];
     public bool SecurityUpdatesOnly { get; init; } = false;
     public required JobSource Source { get; init; }
     public bool UpdateSubdependencies { get; init; } = false;
@@ -27,8 +30,8 @@ public sealed record Job
     public bool VendorDependencies { get; init; } = false;
     public bool RejectExternalCode { get; init; } = false;
     public bool RepoPrivate { get; init; } = false;
-    public object? CommitMessageOptions { get; init; } = null;
-    public object[]? CredentialsMetadata { get; init; } = null;
+    public CommitOptions? CommitMessageOptions { get; init; } = null;
+    public ImmutableArray<Dictionary<string, string>>? CredentialsMetadata { get; init; } = null;
     public int MaxUpdaterRunTime { get; init; } = 0;
 
     public IEnumerable<string> GetAllDirectories()

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Run/ApiModel/PullRequest.cs

@@ -0,0 +1,11 @@
+using NuGet.Versioning;
+
+namespace NuGetUpdater.Core.Run.ApiModel;
+
+public record PullRequest
+{
+    public required string DependencyName { get; init; }
+    public required NuGetVersion DependencyVersion { get; init; }
+    public bool DependencyRemoved { get; init; } = false;
+    public string? Directory { get; init; } = null;
+}