[NSJ -> STJ]Migrate AutoComplete

build/Shared/AotCompatibilityAttributes.cs

@@ -0,0 +1,14 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+#if !NET9_0_OR_GREATER
+namespace System.Diagnostics.CodeAnalysis
+{
+    [AttributeUsage(AttributeTargets.Property, Inherited = false)]
+    internal sealed class FeatureSwitchDefinitionAttribute : Attribute
+    {
+        public FeatureSwitchDefinitionAttribute(string switchName) => SwitchName = switchName;
+        public string SwitchName { get; }
+    }
+}
+#endif

build/Shared/NuGetFeatureFlags.cs

@@ -0,0 +1,35 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using System.Diagnostics.CodeAnalysis;
+using NuGet.Common;
+
+namespace NuGet.Shared
+{
+    internal static class NuGetFeatureFlags
+    {
+        internal const string UseNSJDeserializationSwitchName = "NuGet.UseNSJDeserialization";
+        internal const string UseNSJDeserializationEnvVar = "NUGET_USE_NSJ_DESERIALIZATION";
+
+        private static readonly Lazy<bool> _isNSJDeserializationEnabledByEnvironment =
+            new Lazy<bool>(() => IsNSJDeserializationEnabledByEnvironment(EnvironmentVariableWrapper.Instance));
+
+        /// <summary>Feature switch for NSJ deserialization. Defaults to <see langword="false"/> (STJ is the default).</summary>
+        [FeatureSwitchDefinition(UseNSJDeserializationSwitchName)]
+        internal static bool UseNSJDeserializationFeatureSwitch { get; } =
+            AppContext.TryGetSwitch(UseNSJDeserializationSwitchName, out bool value) && value;
+
+        /// <summary>Returns <see langword="true"/> when env var <c>NUGET_USE_NSJ_DESERIALIZATION</c> is <c>true</c>.</summary>
+        internal static bool IsNSJDeserializationEnabledByEnvironment(IEnvironmentVariableReader? env = null)
+        {
+            if (env is null)
+            {
+                return _isNSJDeserializationEnabledByEnvironment.Value;
+            }
+
+            string? envValue = env.GetEnvironmentVariable(UseNSJDeserializationEnvVar);
+            return string.Equals(envValue, "true", StringComparison.OrdinalIgnoreCase);
+        }
+    }
+}

src/NuGet.Core/NuGet.Protocol/Model/AutoCompleteModel.cs

@@ -0,0 +1,13 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System.Text.Json.Serialization;
+
+namespace NuGet.Protocol.Model
+{
+    internal sealed class AutoCompleteModel
+    {
+        [JsonPropertyName("data")]
+        public string[]? Data { get; set; }
+    }
+}

src/NuGet.Core/NuGet.Protocol/NuGet.Protocol.csproj

@@ -39,6 +39,8 @@
     <Compile Include="$(SharedDirectory)\HashCodeCombiner.cs" />
     <Compile Include="$(SharedDirectory)\NoAllocEnumerateExtensions.cs" />
     <Compile Include="$(SharedDirectory)\NullableAttributes.cs" />
+    <Compile Include="$(SharedDirectory)\NuGetFeatureFlags.cs" />
+    <Compile Include="$(SharedDirectory)\AotCompatibilityAttributes.cs" />
     <Compile Include="$(SharedDirectory)\SimplePool.cs" />
     <Compile Include="$(SharedDirectory)\StringBuilderPool.cs" />
     <Compile Include="$(SharedDirectory)\TaskResult.cs" />

src/NuGet.Core/NuGet.Protocol/Resources/AutoCompleteResourceV3.cs

@@ -8,26 +8,42 @@
 using System.Globalization;
 using System.Linq;
 using System.Net;
+using System.Text.Json;
 using System.Threading;
 using System.Threading.Tasks;
 using Newtonsoft.Json.Linq;
+using NuGet.Common;
 using NuGet.Protocol.Core.Types;
+using NuGet.Protocol.Model;
+using NuGet.Protocol.Utility;
+using NuGet.Shared;
 using NuGet.Versioning;
 
 namespace NuGet.Protocol
 {
     public class AutoCompleteResourceV3 : AutoCompleteResource
     {
-        private readonly RegistrationResourceV3 _regResource;
-        private readonly ServiceIndexResourceV3 _serviceIndex;
-        private readonly HttpSource _client;
+        internal readonly RegistrationResourceV3 _regResource;
+        internal readonly ServiceIndexResourceV3 _serviceIndex;
+        internal readonly HttpSource _client;
+        private readonly IEnvironmentVariableReader _environmentVariableReader;
 
         public AutoCompleteResourceV3(HttpSource client, ServiceIndexResourceV3 serviceIndex, RegistrationResourceV3 regResource)
             : base()
         {
             _regResource = regResource;
             _serviceIndex = serviceIndex;
             _client = client;
+            _environmentVariableReader = EnvironmentVariableWrapper.Instance;
+        }
+
+        internal AutoCompleteResourceV3(HttpSource client, ServiceIndexResourceV3 serviceIndex, RegistrationResourceV3 regResource, IEnvironmentVariableReader environmentVariableReader)
+            : base()
+        {
+            _regResource = regResource;
+            _serviceIndex = serviceIndex;
+            _client = client;
+            _environmentVariableReader = environmentVariableReader;
         }
 
         public override async Task<IEnumerable<string>> IdStartsWith(
@@ -53,17 +69,51 @@ public override async Task<IEnumerable<string>> IdStartsWith(
             queryUrl.Query = queryString;
 
             Common.ILogger logger = log ?? Common.NullLogger.Instance;
-
             var queryUri = queryUrl.Uri;
+
+            if (NuGetFeatureFlags.UseNSJDeserializationFeatureSwitch || NuGetFeatureFlags.IsNSJDeserializationEnabledByEnvironment(_environmentVariableReader))
+            {
+                return await IdStartsWithNsjAsync(packageIdPrefix, logger, queryUri, token);
+            }
+
+            AutoCompleteModel results = await _client.ProcessStreamAsync(
+                new HttpSourceRequest(queryUri, logger),
+                async stream =>
+                {
+                    if (stream == null)
+                    {
+                        return null;
+                    }
+
+                    return await JsonSerializer.DeserializeAsync(stream, JsonContext.Default.AutoCompleteModel, token);
+                },
+                logger,
+                token);
+
+            token.ThrowIfCancellationRequested();
+
+            return results?.Data?.Where(item => item != null && item.StartsWith(packageIdPrefix, StringComparison.OrdinalIgnoreCase))
+                ?? [];
+        }
+
+        private async Task<IEnumerable<string>> IdStartsWithNsjAsync(
+            string packageIdPrefix,
+            Common.ILogger logger,
+            Uri queryUri,
+            CancellationToken token)
+        {
             var results = await _client.GetJObjectAsync(
                 new HttpSourceRequest(queryUri, logger),
                 logger,
                 token);
+
             token.ThrowIfCancellationRequested();
+
             if (results == null)
             {
                 return Enumerable.Empty<string>();
             }
+
             var data = results.Value<JArray>("data");
             if (data == null)
             {

src/NuGet.Core/NuGet.Protocol/Utility/JsonContext.cs

@@ -17,6 +17,7 @@ namespace NuGet.Protocol.Utility
     [JsonSerializable(typeof(HttpFileSystemBasedFindPackageByIdResource.FlatContainerVersionList))]
     [JsonSerializable(typeof(IReadOnlyList<V3VulnerabilityIndexEntry>), TypeInfoPropertyName = "VulnerabilityIndex")]
     [JsonSerializable(typeof(CaseInsensitiveDictionary<IReadOnlyList<PackageVulnerabilityInfo>>), TypeInfoPropertyName = "VulnerabilityPage")]
+    [JsonSerializable(typeof(AutoCompleteModel))]
     internal partial class JsonContext : JsonSerializerContext
     {
     }

test/NuGet.Core.Tests/NuGet.Protocol.Tests/AutoCompleteResourceV3Tests.cs

@@ -5,7 +5,10 @@
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using Moq;
+using NuGet.Common;
 using NuGet.Protocol.Core.Types;
+using NuGet.Shared;
 using NuGet.Test.Utility;
 using Test.Utility;
 using Xunit;
@@ -14,25 +17,26 @@ namespace NuGet.Protocol.Tests
 {
     public class AutoCompleteResourceV3Tests
     {
-        [Fact]
-        public async Task AutoCompleteResourceV3_IdStartsWithAsync()
+        [Theory]
+        [InlineData("true")]  // NSJ path
+        [InlineData("false")] // STJ path
+        public async Task IdStartsWith_BothPaths_ReturnsResultsAsync(string useNsj)
         {
-            // Arrange
             var responses = new Dictionary<string, string>();
-            const string sourceName = "http://testsource.com/v3/index.json";
-            responses.Add(sourceName, JsonData.IndexWithoutFlatContainer);
+            responses.Add("http://testsource.com/v3/index.json", JsonData.IndexWithoutFlatContainer);
             responses.Add("https://api-v3search-0.nuget.org/autocomplete?q=newt&prerelease=true&semVerLevel=2.0.0",
                 JsonData.AutoCompleteEndpointNewtResult);
 
-            var repo = StaticHttpHandler.CreateSource(sourceName, Repository.Provider.GetCoreV3(), responses);
-            var resource = await repo.GetResourceAsync<AutoCompleteResource>(CancellationToken.None);
+            var repo = StaticHttpHandler.CreateSource("http://testsource.com/v3/index.json", Repository.Provider.GetCoreV3(), responses);
+            var resource = (AutoCompleteResourceV3)await repo.GetResourceAsync<AutoCompleteResource>(CancellationToken.None);
 
-            var logger = new TestLogger();
+            var envReader = new Mock<IEnvironmentVariableReader>();
+            envReader.Setup(e => e.GetEnvironmentVariable(NuGetFeatureFlags.UseNSJDeserializationEnvVar)).Returns(useNsj);
+            var testResource = new AutoCompleteResourceV3(resource._client, resource._serviceIndex, resource._regResource, envReader.Object);
 
-            // Act
-            var result = await resource.IdStartsWith("newt", true, logger, CancellationToken.None);
+            var logger = new TestLogger();
+            var result = await testResource.IdStartsWith("newt", true, logger, CancellationToken.None);
 
-            // Assert
             Assert.Equal(10, result.Count());
             Assert.NotEmpty(logger.Messages);
         }

test/NuGet.Core.Tests/NuGet.Protocol.Tests/NuGetFeatureFlagsTests.cs

@@ -0,0 +1,50 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System.Collections.Generic;
+using NuGet.Shared;
+using Test.Utility;
+using Xunit;
+
+namespace NuGet.Protocol.Tests
+{
+    public class NuGetFeatureFlagsTests
+    {
+        [Fact]
+        public void UseNSJDeserializationFeatureSwitch_Default_ReturnsFalse()
+        {
+            Assert.False(NuGetFeatureFlags.UseNSJDeserializationFeatureSwitch);
+        }
+
+        [Fact]
+        public void IsNSJDeserializationEnabledByEnvironment_WhenEnvVarNotSet_ReturnsFalse()
+        {
+            Assert.False(NuGetFeatureFlags.IsNSJDeserializationEnabledByEnvironment(TestEnvironmentVariableReader.EmptyInstance));
+        }
+
+        [Theory]
+        [InlineData("true")]
+        [InlineData("True")]
+        [InlineData("TRUE")]
+        public void IsNSJDeserializationEnabledByEnvironment_WhenEnvVarSetToTrue_ReturnsTrue(string value)
+        {
+            var env = new TestEnvironmentVariableReader(
+                new Dictionary<string, string> { [NuGetFeatureFlags.UseNSJDeserializationEnvVar] = value });
+
+            Assert.True(NuGetFeatureFlags.IsNSJDeserializationEnabledByEnvironment(env));
+        }
+
+        [Theory]
+        [InlineData("false")]
+        [InlineData("0")]
+        [InlineData("1")]
+        [InlineData("anything")]
+        public void IsNSJDeserializationEnabledByEnvironment_WhenEnvVarSetToFalseOrUnrecognized_ReturnsFalse(string value)
+        {
+            var env = new TestEnvironmentVariableReader(
+                new Dictionary<string, string> { [NuGetFeatureFlags.UseNSJDeserializationEnvVar] = value });
+
+            Assert.False(NuGetFeatureFlags.IsNSJDeserializationEnabledByEnvironment(env));
+        }
+    }
+}

test/NuGet.Core.Tests/NuGet.Shared.Tests/NuGet.Shared.Tests.csproj

@@ -9,6 +9,8 @@
     <Compile Include="$(SharedDirectory)\*.cs" Exclude="bin\**;obj\**;**\*.xproj;packages\**" />
     <Compile Remove="$(SharedDirectory)\IsExternalInit.cs" />
     <Compile Remove="$(SharedDirectory)\RequiredModifierAttributes.cs" />
+    <Compile Remove="$(SharedDirectory)\AotCompatibilityAttributes.cs" />
+    <Compile Remove="$(SharedDirectory)\NuGetFeatureFlags.cs" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\..\TestUtilities\Test.Utility\Test.Utility.csproj" />