Refine resource detection (Azure#50936)

Author: live1206

eng/packages/http-client-csharp-mgmt/emitter/src/emitter.ts

@@ -3,7 +3,7 @@
 
 import { EmitContext } from "@typespec/compiler";
 
-import { CodeModel } from "@typespec/http-client-csharp";
+import { CodeModel, CSharpEmitterContext } from "@typespec/http-client-csharp";
 
 import {
   $onEmit as $onAzureEmit,
@@ -19,10 +19,12 @@ export async function $onEmit(context: EmitContext<AzureEmitterOptions>) {
   context.options["sdk-context-options"] ??= azureSDKContextOptions;
   context.options["model-namespace"] ??= true;
   await $onAzureEmit(context);
-}
-
-function updateCodeModel(codeModel: CodeModel): CodeModel {
-  updateClients(codeModel);
 
-  return codeModel;
+  function updateCodeModel(
+    codeModel: CodeModel,
+    sdkContext: CSharpEmitterContext
+  ): CodeModel {
+    updateClients(codeModel, sdkContext);
+    return codeModel;
+  }
 }

eng/packages/http-client-csharp-mgmt/emitter/src/resource-detection.ts

@@ -3,59 +3,196 @@
 
 import {
   CodeModel,
+  CSharpEmitterContext,
   InputClient,
   InputModelType
 } from "@typespec/http-client-csharp";
 import {
   calculateResourceTypeFromPath,
   ResourceMetadata,
+  ResourceOperationKind,
   ResourceScope
 } from "./resource-metadata.js";
-import { DecoratorInfo } from "@azure-tools/typespec-client-generator-core";
 import {
-  armResourceCreateOrUpdate,
-  armResourceOperations,
-  armResourceRead,
+  DecoratorInfo,
+  getClientType,
+  SdkClientType,
+  SdkContext,
+  SdkHttpOperation,
+  SdkMethod,
+  SdkModelType,
+  SdkServiceOperation
+} from "@azure-tools/typespec-client-generator-core";
+import {
+  armResourceActionName,
+  armResourceCreateOrUpdateName,
+  armResourceDeleteName,
+  armResourceInternal,
+  armResourceListName,
+  armResourceReadName,
+  armResourceUpdateName,
+  parentResourceName,
   resourceGroupResource,
   resourceMetadata,
   singleton,
   subscriptionResource,
   tenantResource
 } from "./sdk-context-options.js";
+import { DecoratorApplication, Model, NoTarget } from "@typespec/compiler";
+import { AzureEmitterOptions } from "@azure-typespec/http-client-csharp";
+
+export async function updateClients(
+  codeModel: CodeModel,
+  sdkContext: CSharpEmitterContext
+) {
+  const serviceMethods = new Map<string, SdkMethod<SdkHttpOperation>>(
+    getAllSdkClients(sdkContext)
+      .flatMap((c) => c.methods)
+      .map((obj) => [obj.crossLanguageDefinitionId, obj])
+  );
+  const models = new Map<string, SdkModelType>(
+    sdkContext.sdkPackage.models.map((m) => [m.crossLanguageDefinitionId, m])
+  );
+  const resourceModels = getAllResourceModels(codeModel);
+
+  const resourceModelMap = new Map<string, ResourceMetadata>(
+    resourceModels.map((m) => [
+      m.crossLanguageDefinitionId,
+      {
+        resourceType: "",
+        isSingleton: m.decorators?.some((d) => d.name == singleton) ?? false,
+        resourceScope: getResourceScope(m),
+        methods: [],
+        parentResource: getParentResourceModelId(
+          sdkContext,
+          models.get(m.crossLanguageDefinitionId)
+        )
+      } as ResourceMetadata
+    ])
+  );
 
-export function updateClients(codeModel: CodeModel) {
   // first we flatten all possible clients in the code model
   const clients = getAllClients(codeModel);
 
-  // to fully calculation the resource metadata, we have to go with 2 passes
-  // in which the first pass we gather everything we could for each client
-  // the second pass we figure out there cross references between the clients (such as parent resource)
-  // then pass to update all the clients with their own information
-  const metadata: Map<InputClient, ResourceMetadata> = new Map();
+  // then we iterate over all the clients and their methods to find the resource operations
+  // and add them to the resource model metadata
+  // we also calculate the resource type from the path of the operation
   for (const client of clients) {
-    gatherResourceMetadata(client, metadata);
+    for (const method of client.methods) {
+      const serviceMethod = serviceMethods.get(
+        method.crossLanguageDefinitionId
+      );
+      const [kind, modelId] =
+        parseResourceOperation(serviceMethod, sdkContext) ?? [];
+      if (modelId && kind) {
+        const entry = resourceModelMap.get(modelId);
+        entry?.methods.push({
+          id: method.crossLanguageDefinitionId,
+          kind
+        });
+        if (entry && !entry.resourceType) {
+          entry.resourceType = calculateResourceTypeFromPath(
+            method.operation.path
+          );
+        }
+      }
+    }
   }
 
-  // populate the parent resource information
+  // the last step, add the decorator to the resource model
+  for (const model of resourceModels) {
+    const metadata = resourceModelMap.get(model.crossLanguageDefinitionId);
+    if (metadata) {
+      addResourceMetadata(model, metadata);
+    }
+  }
+}
 
-  // the last step, add the decorator to the client
-  for (const client of clients) {
-    const resourceMetadata = metadata.get(client);
-    if (resourceMetadata) {
-      addResourceMetadata(client, resourceMetadata);
+function parseResourceOperation(
+  serviceMethod: SdkMethod<SdkHttpOperation> | undefined,
+  sdkContext: CSharpEmitterContext
+): [ResourceOperationKind, string | undefined] | undefined {
+  const decorators = serviceMethod?.__raw?.decorators;
+  for (const decorator of decorators ?? []) {
+    if (decorator.definition?.name === armResourceReadName) {
+      return [
+        ResourceOperationKind.Get,
+        getResourceModelId(sdkContext, decorator)
+      ];
+    } else if (decorator.definition?.name == armResourceCreateOrUpdateName) {
+      return [
+        ResourceOperationKind.Create,
+        getResourceModelId(sdkContext, decorator)
+      ];
+    } else if (decorator.definition?.name == armResourceUpdateName) {
+      return [
+        ResourceOperationKind.Update,
+        getResourceModelId(sdkContext, decorator)
+      ];
+    } else if (decorator.definition?.name == armResourceDeleteName) {
+      return [
+        ResourceOperationKind.Delete,
+        getResourceModelId(sdkContext, decorator)
+      ];
+    } else if (decorator.definition?.name == armResourceListName) {
+      return [
+        ResourceOperationKind.List,
+        getResourceModelId(sdkContext, decorator)
+      ];
+    } else if (decorator.definition?.name == armResourceActionName) {
+      return [
+        ResourceOperationKind.Action,
+        getResourceModelId(sdkContext, decorator)
+      ];
     }
   }
+  return undefined;
 }
 
-export function getAllClients(codeModel: CodeModel): InputClient[] {
-  const clients: InputClient[] = [];
-  for (const client of codeModel.clients) {
+function getParentResourceModelId(
+  sdkContext: CSharpEmitterContext,
+  model: SdkModelType | undefined
+): string | undefined {
+  const decorators = (model?.__raw as Model)?.decorators;
+  const parentResourceDecorator = decorators?.find(
+    (d) => d.definition?.name == parentResourceName
+  );
+  return getResourceModelId(sdkContext, parentResourceDecorator) ?? undefined;
+}
+
+function getResourceModelId(
+  sdkContext: CSharpEmitterContext,
+  decorator?: DecoratorApplication
+): string | undefined {
+  if (!decorator) return undefined;
+  const model = getClientType(
+    sdkContext,
+    decorator.args[0].value as Model
+  ) as SdkModelType;
+  if (model) {
+    return model.crossLanguageDefinitionId;
+  } else {
+    sdkContext.logger.reportDiagnostic({
+      code: "general-error",
+      message: `Resource model not found for decorator ${decorator.decorator.name}`,
+      target: NoTarget,
+      severity: "error"
+    });
+    return undefined;
+  }
+}
+
+export function getAllSdkClients(
+  sdkContext: SdkContext<AzureEmitterOptions, SdkHttpOperation>
+): SdkClientType<SdkServiceOperation>[] {
+  const clients: SdkClientType<SdkServiceOperation>[] = [];
+  for (const client of sdkContext.sdkPackage.clients) {
     traverseClient(client);
   }
 
   return clients;
 
-  function traverseClient(client: InputClient) {
+  function traverseClient(client: SdkClientType<SdkServiceOperation>) {
     clients.push(client);
     if (client.children) {
       for (const child of client.children) {
@@ -65,97 +202,65 @@ export function getAllClients(codeModel: CodeModel): InputClient[] {
   }
 }
 
-function gatherResourceMetadata(
-  client: InputClient,
-  metadataMap: Map<InputClient, ResourceMetadata>
-) {
-  // TODO: we can implement this decorator in TCGC until we meet the corner case
-  // if the client has resourceMetadata decorator, it is a resource client and we don't need to add it again
-  if (client.decorators?.some((d) => d.name == resourceMetadata)) {
-    return;
+export function getAllClients(codeModel: CodeModel): InputClient[] {
+  const clients: InputClient[] = [];
+  for (const client of codeModel.clients) {
+    traverseClient(client);
   }
 
-  // TODO: Once we have the ability to get resource hierarchy from TCGC directly, we can remove this implementation
-  // A resource client should have decorator armResourceOperations and contains either a get operation(containing armResourceRead deocrator) or a put operation(containing armResourceCreateOrUpdate decorator)
-  if (
-    client.decorators?.some((d) => d.name == armResourceOperations) &&
-    client.methods.some(
-      (m) =>
-        m.operation.decorators?.some(
-          (d) => d.name == armResourceRead || armResourceCreateOrUpdate
-        )
-    )
-  ) {
-    let resourceModel: InputModelType | undefined = undefined;
-    let isSingleton: boolean = false;
-    let resourceType: string | undefined = undefined;
-    // We will try to get resource metadata from put operation firstly, if not found, we will try to get it from get operation
-    const putOperation = client.methods.find(
-      (m) =>
-        m.operation.decorators?.some((d) => d.name == armResourceCreateOrUpdate)
-    )?.operation;
-    if (putOperation) {
-      const path = putOperation.path;
-      resourceType = calculateResourceTypeFromPath(path);
-      resourceModel = putOperation.responses.filter((r) => r.bodyType)[0]
-        .bodyType as InputModelType;
-      isSingleton =
-        resourceModel.decorators?.some((d) => d.name == singleton) ?? false;
-    } else {
-      const getOperation = client.methods.find(
-        (m) => m.operation.decorators?.some((d) => d.name == armResourceRead)
-      )?.operation;
-      if (getOperation) {
-        const path = getOperation.path;
-        resourceType = calculateResourceTypeFromPath(path);
-        resourceModel = getOperation.responses.filter((r) => r.bodyType)[0]
-          .bodyType as InputModelType;
-        isSingleton =
-          resourceModel.decorators?.some((d) => d.name == singleton) ?? false;
+  return clients;
+
+  function traverseClient(client: InputClient) {
+    clients.push(client);
+    if (client.children) {
+      for (const child of client.children) {
+        traverseClient(child);
       }
     }
+  }
+}
 
-    if (resourceModel && resourceType) {
-      // find the scope on its model
-      const metadata: ResourceMetadata = {
-        resourceModel: resourceModel,
-        resourceClient: client,
-        resourceType: resourceType,
-        isSingleton: isSingleton,
-        resourceScope: getResourceScope(resourceModel)
-      };
-      metadataMap.set(client, metadata);
+function getAllResourceModels(codeModel: CodeModel): InputModelType[] {
+  const resourceModels: InputModelType[] = [];
+  for (const model of codeModel.models) {
+    if (model.decorators?.some((d) => d.name == armResourceInternal)) {
+      model.crossLanguageDefinitionId;
+      resourceModels.push(model);
     }
   }
+  return resourceModels;
+}
 
-  function getResourceScope(model: InputModelType): ResourceScope {
-    const decorators = model.decorators;
-    if (decorators?.some((d) => d.name == tenantResource)) {
-      return ResourceScope.Tenant;
-    } else if (decorators?.some((d) => d.name == subscriptionResource)) {
-      return ResourceScope.Subscription;
-    } else if (decorators?.some((d) => d.name == resourceGroupResource)) {
-      return ResourceScope.ResourceGroup;
-    }
-    return ResourceScope.ResourceGroup; // all the templates work as if there is a resource group decorator when there is no such decorator
+function getResourceScope(model: InputModelType): ResourceScope {
+  const decorators = model.decorators;
+  if (decorators?.some((d) => d.name == tenantResource)) {
+    return ResourceScope.Tenant;
+  } else if (decorators?.some((d) => d.name == subscriptionResource)) {
+    return ResourceScope.Subscription;
+  } else if (decorators?.some((d) => d.name == resourceGroupResource)) {
+    return ResourceScope.ResourceGroup;
   }
+  return ResourceScope.ResourceGroup; // all the templates work as if there is a resource group decorator when there is no such decorator
 }
 
-function addResourceMetadata(client: InputClient, metadata: ResourceMetadata) {
+function addResourceMetadata(
+  model: InputModelType,
+  metadata: ResourceMetadata
+) {
   const resourceMetadataDecorator: DecoratorInfo = {
     name: resourceMetadata,
     arguments: {
-      resourceModel: metadata.resourceModel.crossLanguageDefinitionId,
-      resourceClient: metadata.resourceClient.crossLanguageDefinitionId,
       isSingleton: metadata.isSingleton,
       resourceType: metadata.resourceType,
-      resourceScope: metadata.resourceScope
+      resourceScope: metadata.resourceScope,
+      methods: metadata.methods,
+      parentResource: metadata.parentResource
     }
   };
 
-  if (!client.decorators) {
-    client.decorators = [];
+  if (!model.decorators) {
+    model.decorators = [];
   }
 
-  client.decorators.push(resourceMetadataDecorator);
+  model.decorators.push(resourceMetadataDecorator);
 }