Implement mgmt resource

eng/Packages.Data.props

@@ -262,7 +262,7 @@
   </ItemGroup>
 
   <ItemGroup Condition="'$(IsGeneratorLibrary)' == 'true'">
-    <PackageReference Update="Microsoft.TypeSpec.Generator.ClientModel" Version="1.0.0-alpha.20250211.5" />
+    <PackageReference Update="Microsoft.TypeSpec.Generator.ClientModel" Version="1.0.0-alpha.20250213.9" />
   </ItemGroup>
 
   <!--

eng/packages/http-client-csharp/generator/Azure.Generator/src/AzureClientPlugin.cs

@@ -1,6 +1,7 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
+using Azure.ResourceManager;
 using Azure.Generator.Utilities;
 using Microsoft.CodeAnalysis;
 using Microsoft.TypeSpec.Generator;
@@ -30,6 +31,9 @@ public class AzureClientPlugin : ClientModelPlugin
     public override AzureOutputLibrary OutputLibrary => _azureOutputLibrary ??= new();
 
     internal ResourceDetection ResourceDetection { get; } = new();
+    internal ParentDetection ParentDetection { get; } = new();
+    internal ScopeDetection ScopeDetection { get; } = new();
+    internal SingletonDetection SingletonDetection { get; } = new();
 
     /// <summary>
     /// The Azure client plugin to generate the Azure client SDK.
@@ -55,6 +59,8 @@ public override void Configure()
         AddVisitor(new NamespaceVisitor());
         if (IsAzureArm.Value)
         {
+            // Include Azure.ResourceManager
+            AddMetadataReference(MetadataReference.CreateFromFile(typeof(ArmClient).Assembly.Location));
             AddVisitor(new RestClientVisitor());
         }
     }

eng/packages/http-client-csharp/generator/Azure.Generator/src/AzureOutputLibrary.cs

@@ -5,26 +5,56 @@
 using Azure.Generator.Providers;
 using Azure.Generator.Utilities;
 using Microsoft.TypeSpec.Generator.ClientModel;
+using Microsoft.TypeSpec.Generator.Input;
 using Microsoft.TypeSpec.Generator.Providers;
+using System;
 using System.Collections.Generic;
+using System.Linq;
 
 namespace Azure.Generator
 {
     /// <inheritdoc/>
     public class AzureOutputLibrary : ScmOutputLibrary
     {
-        // TODO: categorize clients into operationSets, which contains operations sharing the same Path
-        private Dictionary<string, OperationSet> _pathToOperationSetMap;
-        private Dictionary<string, HashSet<OperationSet>> _resourceDataBySpecNameMap;
+        //TODO: Move these to InputLibrary instead
+        private Dictionary<RequestPath, OperationSet> _pathToOperationSetMap;
+        private Dictionary<string, HashSet<OperationSet>> _specNameToOperationSetsMap;
+        private Dictionary<string, InputModelType> _inputTypeMap;
 
         /// <inheritdoc/>
         public AzureOutputLibrary()
         {
             _pathToOperationSetMap = CategorizeClients();
-            _resourceDataBySpecNameMap = EnsureResourceDataMap();
+            _specNameToOperationSetsMap = EnsureOperationsetMap();
+            _inputTypeMap = AzureClientPlugin.Instance.InputLibrary.InputNamespace.Models.OfType<InputModelType>().ToDictionary(model => model.Name);
         }
 
-        private Dictionary<string, HashSet<OperationSet>> EnsureResourceDataMap()
+        private MgmtLongRunningOperationProvider? _armOperation;
+        internal MgmtLongRunningOperationProvider ArmOperation => _armOperation ??= new MgmtLongRunningOperationProvider(false);
+
+        private MgmtLongRunningOperationProvider? _genericArmOperation;
+        internal MgmtLongRunningOperationProvider GenericArmOperation => _genericArmOperation ??= new MgmtLongRunningOperationProvider(true);
+
+        private IReadOnlyList<ResourceProvider> BuildResources()
+        {
+            var result = new List<ResourceProvider>();
+            foreach ((var schemaName, var operationSets) in _specNameToOperationSetsMap)
+            {
+                var model = _inputTypeMap[schemaName];
+                var resourceData = (ResourceDataProvider)AzureClientPlugin.Instance.TypeFactory.CreateModel(model)!;
+                foreach (var operationSet in operationSets)
+                {
+                    var requestPath = operationSet.RequestPath;
+                    var resourceType = ResourceDetection.GetResourceTypeFromPath(requestPath);
+                    var resource = new ResourceProvider(operationSet, schemaName, resourceData, resourceType);
+                    AzureClientPlugin.Instance.AddTypeToKeep(resource.Name);
+                    result.Add(resource);
+                }
+            }
+            return result;
+        }
+
+        private Dictionary<string, HashSet<OperationSet>> EnsureOperationsetMap()
         {
             var result = new Dictionary<string, HashSet<OperationSet>>();
             foreach (var operationSet in _pathToOperationSetMap.Values)
@@ -44,16 +74,14 @@ private Dictionary<string, HashSet<OperationSet>> EnsureResourceDataMap()
             return result;
         }
 
-        private Dictionary<string, OperationSet> CategorizeClients()
+        private Dictionary<RequestPath, OperationSet> CategorizeClients()
         {
-            var result = new Dictionary<string, OperationSet>();
+            var result = new Dictionary<RequestPath, OperationSet>();
             foreach (var inputClient in AzureClientPlugin.Instance.InputLibrary.InputNamespace.Clients)
             {
-                var requestPathList = new HashSet<string>();
                 foreach (var operation in inputClient.Operations)
                 {
                     var path = operation.GetHttpPath();
-                    requestPathList.Add(path);
                     if (result.TryGetValue(path, out var operationSet))
                     {
                         operationSet.Add(operation);
@@ -75,22 +103,28 @@ private Dictionary<string, OperationSet> CategorizeClients()
         }
 
         /// <inheritdoc/>
-        // TODO: generate resources and collections
+        // TODO: generate collections
         protected override TypeProvider[] BuildTypeProviders()
         {
+            var baseProviders = base.BuildTypeProviders();
             if (AzureClientPlugin.Instance.IsAzureArm.Value == true)
             {
-                var armOperation = new MgmtLongRunningOperationProvider(false);
-                var genericArmOperation = new MgmtLongRunningOperationProvider(true);
-
-                // TODO: remove them once they are referenced in Resource operation implementation
-                AzureClientPlugin.Instance.AddTypeToKeep(armOperation.Name);
-                AzureClientPlugin.Instance.AddTypeToKeep(genericArmOperation.Name);
-                return [.. base.BuildTypeProviders(), new RequestContextExtensionsDefinition(), armOperation, genericArmOperation];
+                //BuildLROProviders();
+                var resources = BuildResources();
+                return [.. base.BuildTypeProviders(), new RequestContextExtensionsDefinition(), ArmOperation, GenericArmOperation, .. resources, .. resources.Select(r => r.Source)];
             }
             return [.. base.BuildTypeProviders(), new RequestContextExtensionsDefinition()];
         }
 
-        internal bool IsResource(string name) => _resourceDataBySpecNameMap.ContainsKey(name);
+        private void BuildLROProviders()
+        {
+            // TODO: remove them once they are referenced in Resource operation implementation
+            AzureClientPlugin.Instance.AddTypeToKeep(ArmOperation.Name);
+            AzureClientPlugin.Instance.AddTypeToKeep(GenericArmOperation.Name);
+        }
+
+        internal bool IsResource(string name) => _specNameToOperationSetsMap.ContainsKey(name);
+
+        internal Lazy<IEnumerable<OperationSet>> ResourceOperationSets => new(() => _specNameToOperationSetsMap.Values.SelectMany(x => x));
     }
 }

eng/packages/http-client-csharp/generator/Azure.Generator/src/Mgmt/Models/OperationSet.cs

@@ -17,12 +17,12 @@ namespace Azure.Generator.Mgmt.Models
     /// </summary>
     internal class OperationSet : IReadOnlyCollection<InputOperation>, IEquatable<OperationSet>
     {
-        private readonly InputClient? _inputClient;
-
         /// <summary>
         /// The raw request path of string of the operations in this <see cref="OperationSet"/>
         /// </summary>
-        public string RequestPath { get; }
+        public RequestPath RequestPath { get; }
+
+        public InputClient InputClient { get; }
 
         /// <summary>
         /// The operation set
@@ -31,9 +31,9 @@ internal class OperationSet : IReadOnlyCollection<InputOperation>, IEquatable<Op
 
         public int Count => _operations.Count;
 
-        public OperationSet(string requestPath, InputClient? inputClient)
+        public OperationSet(RequestPath requestPath, InputClient inputClient)
         {
-            _inputClient = inputClient;
+            InputClient = inputClient;
             RequestPath = requestPath;
             _operations = new HashSet<InputOperation>();
         }
@@ -46,7 +46,7 @@ public OperationSet(string requestPath, InputClient? inputClient)
         public void Add(InputOperation operation)
         {
             var path = operation.GetHttpPath();
-            if (path != RequestPath)
+            if (!path.Equals(RequestPath))
                 throw new InvalidOperationException($"Cannot add operation with path {path} to OperationSet with path {RequestPath}");
             _operations.Add(operation);
         }

eng/packages/http-client-csharp/generator/Azure.Generator/src/Mgmt/Models/RequestPath.cs

@@ -0,0 +1,157 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+
+namespace Azure.Generator.Mgmt.Models
+{
+    internal class RequestPath : IEquatable<RequestPath>, IReadOnlyList<string>
+    {
+        private const string ProviderPath = "/subscriptions/{subscriptionId}/providers/{resourceProviderNamespace}";
+        private const string FeaturePath = "/subscriptions/{subscriptionId}/providers/Microsoft.Features/providers/{resourceProviderNamespace}/features";
+
+        public const string ManagementGroupScopePrefix = "/providers/Microsoft.Management/managementGroups";
+        public const string ResourceGroupScopePrefix = "/subscriptions/{subscriptionId}/resourceGroups";
+        public const string SubscriptionScopePrefix = "/subscriptions";
+        public const string TenantScopePrefix = "/tenants";
+        public const string Providers = "/providers";
+
+        public static readonly RequestPath ManagementGroup = new("/providers/Microsoft.Management/managementGroups/{managementGroupId}");
+        public static readonly RequestPath ResourceGroup = new("/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}");
+        public static readonly RequestPath Subscription = new("/subscriptions/{subscriptionId}");
+        public static readonly RequestPath Tenant = new(string.Empty);
+
+        private string _path;
+        private IReadOnlyList<string> _segments;
+
+        public RequestPath(string path)
+        {
+            _path = path;
+            _segments = path.Split('/', StringSplitOptions.RemoveEmptyEntries);
+            IndexOfLastProviders = _path.LastIndexOf(Providers);
+        }
+
+        public RequestPath(IEnumerable<string> segments)
+        {
+            _segments = segments.ToArray();
+            _path = string.Join("", _segments);
+        }
+
+        public int Count => _segments.Count;
+
+        public string SerializedPath => _path;
+
+        public int IndexOfLastProviders { get; }
+
+        public string this[int index] => _segments[index];
+
+        /// <summary>
+        /// Check if this <see cref="RequestPath"/> is a prefix path of the other request path.
+        /// Note that this.IsAncestorOf(this) will return false which indicates that this method is testing the "proper ancestor" like a proper subset.
+        /// </summary>
+        /// <param name="other"></param>
+        /// <returns></returns>
+        public bool IsAncestorOf(RequestPath other)
+        {
+            // To be the parent of other, you must at least be shorter than other.
+            if (other.Count <= Count)
+                return false;
+            for (int i = 0; i < Count; i++)
+            {
+                // we need the segment to be identical when strict is true (which is the default value)
+                // when strict is false, we also need the segment to be identical if it is constant.
+                // but if it is a reference, we only require they have the same type, do not require they have the same variable name.
+                // This case happens a lot during the management group parent detection - different RP calls this different things
+                if (!this[i].Equals(other[i]))
+                    return false;
+            }
+            return true;
+        }
+
+        /// <summary>
+        /// Trim this from the other and return the <see cref="RequestPath"/>that remain.
+        /// The result is "other - this" by removing this as a prefix of other.
+        /// If this == other, return empty request path
+        /// </summary>
+        /// <param name="other"></param>
+        /// <returns></returns>
+        /// <exception cref="InvalidOperationException">if this.IsAncestorOf(other) is false</exception>
+        public RequestPath TrimAncestorFrom(RequestPath other)
+        {
+            if (TryTrimAncestorFrom(other, out var diff))
+                return diff;
+
+            throw new InvalidOperationException($"Request path {this} is not parent of {other}");
+        }
+
+        private bool TryTrimAncestorFrom(RequestPath other, [MaybeNullWhen(false)] out RequestPath diff)
+        {
+            diff = default;
+            if (this == other)
+            {
+                diff = Tenant;
+                return true;
+            }
+            if (IsAncestorOf(other))
+            {
+                diff = new RequestPath(string.Join("", other._segments.Skip(Count)));
+                return true;
+            }
+            // Handle the special case of trim provider from feature
+            else if (_path == ProviderPath && other._path.StartsWith(FeaturePath))
+            {
+                diff = new RequestPath(string.Join("", other._segments.Skip(Count + 2)));
+                return true;
+            }
+            return false;
+        }
+
+        public bool Equals(RequestPath? other)
+        {
+            if (Count != other?.Count)
+                return false;
+            for (int i = 0; i < Count; i++)
+            {
+                if (!this[i].Equals(other[i]))
+                    return false;
+            }
+            return true;
+        }
+
+        public override bool Equals(object? obj) => obj is RequestPath other && Equals(other);
+
+        public override int GetHashCode() => _path.GetHashCode();
+
+        public override string ToString() => _path;
+
+        public IEnumerator<String> GetEnumerator() => _segments.GetEnumerator();
+
+        IEnumerator IEnumerable.GetEnumerator() => _segments.GetEnumerator();
+
+        public static bool operator ==(RequestPath left, RequestPath right)
+        {
+            return left.Equals(right);
+        }
+
+        public static bool operator !=(RequestPath left, RequestPath right)
+        {
+            return !(left == right);
+        }
+
+        public static implicit operator string(RequestPath requestPath)
+        {
+            return requestPath._path;
+        }
+
+        public static bool IsSegmentConstant(string segment)
+        {
+            var trimmed = segment.TrimStart('{').TrimEnd('}');
+            var isScope = trimmed == "scope";
+            return !isScope && !segment.StartsWith('{');
+        }
+    }
+}

eng/packages/http-client-csharp/generator/Azure.Generator/src/Mgmt/Models/SingletonResourceSuffix.cs

@@ -0,0 +1,29 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+using System.Collections.Generic;
+
+namespace Azure.Generator.Mgmt.Models
+{
+    internal class SingletonResourceSuffix
+    {
+        public static SingletonResourceSuffix Parse(IReadOnlyList<string> segments)
+        {
+            // put the segments in pairs
+            var pairs = new List<(string Key, string Value)>();
+            for (int i = 0; i < segments.Count; i += 2)
+            {
+                pairs.Add((segments[i], segments[i + 1]));
+            }
+
+            return new SingletonResourceSuffix(pairs);
+        }
+
+        private IReadOnlyList<(string Key, string Value)> _pairs;
+
+        private SingletonResourceSuffix(IReadOnlyList<(string Key, string Value)> pairs)
+        {
+            _pairs = pairs;
+        }
+    }
+}

eng/packages/http-client-csharp/generator/Azure.Generator/src/Primitives/KnownAzureParameters.cs

@@ -0,0 +1,18 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+using Microsoft.TypeSpec.Generator.Primitives;
+using Microsoft.TypeSpec.Generator.Providers;
+using System.Threading;
+
+namespace Azure.Generator.Primitives
+{
+    internal class KnownAzureParameters
+    {
+        public static readonly ParameterProvider Response = new("response", $"The response from the service.", new CSharpType(typeof(Response)));
+
+        public static readonly ParameterProvider WaitUntil = new("waitUntil", $"<see cref=\"WaitUntil.Completed\"/> if the method should wait to return until the long-running operation has completed on the service; <see cref=\"WaitUntil.Started\"/> if it should return after starting the operation. For more information on long-running operations, please see <see href=\"https://github.com/Azure/azure-sdk-for-net/blob/main/sdk/core/Azure.Core/samples/LongRunningOperations.md\"> Azure.Core Long-Running Operation samples</see>.", new CSharpType(typeof(WaitUntil)));
+
+        public static readonly ParameterProvider CancellationTokenWithoutDefault = new("cancellationToken", $"The cancellation token to use.", new CSharpType(typeof(CancellationToken)));
+    }
+}