@azure-tools/typespec-ts 0.54.0 → 0.54.2

package/src/transform/transform-schemas.ts

@@ -0,0 +1,212 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import { SdkClient, getHttpOperationWithCache } from "@azure-tools/typespec-client-generator-core";
+import { Model, Type } from "@typespec/compiler";
+import { HttpOperation, getServers } from "@typespec/http";
+import { KnownMediaType, extractMediaTypes } from "../utils/media-types.js";
+import {
+  getBodyType,
+  getDefaultService,
+  getSchemaForType,
+  includeDerivedModel,
+  isAzureCoreErrorType,
+  trimUsage,
+} from "../utils/model-utils.js";
+
+import { useContext } from "../context-manager.js";
+import { SchemaContext } from "../rlc-common/index.js";
+import { listOperationsUnderRLCClient } from "../utils/client-utils.js";
+import { SdkContext } from "../utils/interfaces.js";
+
+export function transformSchemas(client: SdkClient, dpgContext: SdkContext) {
+  const program = dpgContext.program;
+  const metatree = useContext("rlcMetaTree");
+  const schemas: Map<string, SchemaContext[]> = new Map<string, SchemaContext[]>();
+  const schemaMap: Map<any, any> = new Map<any, any>();
+  const usageMap = new Map<Type, SchemaContext[]>();
+  const requestBodySet = new Set<Type>();
+  const contentTypeMap = new Map<Type, KnownMediaType[]>();
+  for (const op of listOperationsUnderRLCClient(client)) {
+    const route = getHttpOperationWithCache(dpgContext, op);
+    // ignore overload base operation
+    if (route.overloads && route.overloads?.length > 0) {
+      continue;
+    }
+    transformSchemaForRoute(route);
+  }
+  function transformSchemaForRoute(route: HttpOperation) {
+    if (route.parameters) {
+      for (const param of route.parameters.parameters) {
+        getGeneratedModels(param.param, SchemaContext.Input);
+      }
+    }
+    const bodyModel = getBodyType(route);
+    if (
+      bodyModel &&
+      (bodyModel.kind === "Model" || bodyModel.kind === "Union" || bodyModel.kind === "Enum")
+    ) {
+      requestBodySet.add(bodyModel);
+      const contentTypes: KnownMediaType[] = extractMediaTypes(
+        route.parameters.body?.contentTypes ?? [],
+      );
+      if (contentTypes.length > 0) {
+        contentTypeMap.set(bodyModel, contentTypes);
+      }
+      getGeneratedModels(bodyModel, SchemaContext.Input);
+    }
+    for (const resp of route.responses) {
+      if (isAzureCoreErrorType(dpgContext.program, resp.type)) {
+        continue;
+      }
+      for (const resps of resp.responses) {
+        const headers = resps?.headers;
+        if (headers && Object.keys(headers).length) {
+          for (const value of Object.values(headers)) {
+            getGeneratedModels(value, SchemaContext.Output);
+          }
+        }
+        if (resps.body?.contentTypeProperty) {
+          getGeneratedModels(resps.body.contentTypeProperty, SchemaContext.Output);
+        }
+        const respModel = resps?.body?.type;
+        if (!respModel) {
+          continue;
+        }
+        getGeneratedModels(respModel, SchemaContext.Output);
+      }
+    }
+  }
+  function transformHostParameters() {
+    const serviceNs = getDefaultService(program, dpgContext.rlcOptions?.isModularLibrary)?.type;
+    if (serviceNs) {
+      const host = getServers(program, serviceNs);
+      if (host && host?.[0] && host?.[0]?.parameters) {
+        for (const key of host[0].parameters.keys()) {
+          const type = host?.[0]?.parameters.get(key)?.type;
+          if (!type) {
+            continue;
+          }
+          getGeneratedModels(type, SchemaContext.Input);
+        }
+      }
+    }
+  }
+  transformHostParameters();
+  usageMap.forEach((context, tspModel) => {
+    const model = getSchemaForType(dpgContext, tspModel, {
+      usage: context,
+      isRequestBody: requestBodySet.has(tspModel),
+      isParentRequestBody: false,
+      mediaTypes: contentTypeMap.get(tspModel),
+    });
+    if (model) {
+      model.usage = context;
+    }
+    metatree.set(tspModel, { rlcType: model });
+    if (model.name === "") {
+      return;
+    }
+    const pureModel = JSON.stringify(trimUsage(model));
+    schemaMap.set(pureModel, model);
+    const usageSet = new Set((schemas.get(pureModel) ?? []).concat(context));
+    schemas.set(pureModel, Array.from(usageSet));
+  });
+
+  function setModelMap(type: Type, schemaContext: SchemaContext) {
+    if (usageMap.get(type)) {
+      const context = usageMap.get(type);
+      if (context && context.indexOf(schemaContext) === -1) {
+        context.push(schemaContext);
+        usageMap.set(type, context);
+      }
+    } else {
+      usageMap.set(type, [schemaContext]);
+    }
+  }
+  function getGeneratedModels(model: Type, context: SchemaContext) {
+    if (model.kind === "Model") {
+      setModelMap(model, context);
+      const indexer = (model as Model).indexer;
+      if (
+        indexer?.value &&
+        (!usageMap.get(indexer?.value) || !usageMap.get(indexer?.value)?.includes(context))
+      ) {
+        getGeneratedModels(indexer.value, context);
+      }
+      for (const prop of model.properties) {
+        const [, propType] = prop;
+        if (usageMap.get(propType.type)?.includes(context)) {
+          continue;
+        }
+        if (propType.type.kind === "Model") {
+          if (isAzureCoreErrorType(dpgContext.program, propType.type)) {
+            continue;
+          }
+          getGeneratedModels(propType.type, context);
+        } else if (propType.type.kind === "Union") {
+          const variants = Array.from(propType.type.variants.values());
+          for (const variant of variants) {
+            if (
+              (variant.type.kind === "Model" ||
+                variant.type.kind === "Union" ||
+                variant.type.kind === "Enum") &&
+              (!usageMap.get(variant.type) || !usageMap.get(variant.type)?.includes(context))
+            ) {
+              getGeneratedModels(variant.type, context);
+            }
+          }
+          // build type details for named union
+          if (!propType.type.expression) {
+            setModelMap(propType.type, context);
+          }
+        } else if (propType.type.kind === "Enum") {
+          getGeneratedModels(propType.type, context);
+        }
+      }
+      const baseModel = model.baseModel;
+      if (
+        baseModel &&
+        baseModel.kind === "Model" &&
+        (!usageMap.get(baseModel) || !usageMap.get(baseModel)?.includes(context))
+      ) {
+        getGeneratedModels(baseModel, context);
+      }
+      const derivedModels = model.derivedModels.filter((dm) => {
+        return includeDerivedModel(dm);
+      });
+
+      // getSchemaOrRef on all children to push them into components.schemas
+      for (const child of derivedModels) {
+        if (
+          child.kind === "Model" &&
+          (!usageMap.get(child) || !usageMap.get(child)?.includes(context))
+        ) {
+          getGeneratedModels(child, context);
+        }
+      }
+    } else if (model.kind === "Union") {
+      const variants = Array.from(model.variants.values());
+      for (const variant of variants) {
+        if (
+          (variant.type.kind === "Model" || variant.type.kind === "Union") &&
+          (!usageMap.get(variant.type) || !usageMap.get(variant.type)?.includes(context))
+        ) {
+          getGeneratedModels(variant.type, context);
+        }
+      }
+      // build type details for named union
+      if (!model.expression) {
+        setModelMap(model, context);
+      }
+    } else if (model.kind === "ModelProperty") {
+      getGeneratedModels(model.type, context);
+    } else if (model.kind === "Enum") {
+      setModelMap(model, context);
+    }
+  }
+  const allSchemas = Array.from(schemas, function (item) {
+    return { ...schemaMap.get(item[0]), usage: item[1] };
+  });
+  return allSchemas;
+}

package/src/transform/transform-telemetry-info.ts

@@ -0,0 +1,33 @@
+import {
+  getHttpOperationWithCache,
+  SdkClient,
+  SdkContext,
+} from "@azure-tools/typespec-client-generator-core";
+import { TelemetryInfo } from "../rlc-common/index.js";
+import { listOperationsUnderRLCClient } from "../utils/client-utils.js";
+import { getCustomRequestHeaderNameForOperation } from "../utils/operation-util.js";
+
+export function transformTelemetryInfo(
+  client: SdkClient,
+  dpgContext: SdkContext,
+): TelemetryInfo | undefined {
+  const customRequestIdHeaderName = getCustomRequestHeaderNameForClient(dpgContext, client);
+  if (customRequestIdHeaderName) {
+    return {
+      customRequestIdHeaderName,
+    };
+  }
+  return undefined;
+}
+
+function getCustomRequestHeaderNameForClient(dpgContext: SdkContext, client: SdkClient) {
+  for (const op of listOperationsUnderRLCClient(client)) {
+    const headerName = getCustomRequestHeaderNameForOperation(
+      getHttpOperationWithCache(dpgContext, op),
+    );
+    if (headerName !== undefined) {
+      return headerName;
+    }
+  }
+  return undefined;
+}

package/src/transform/transform.ts

@@ -1,6 +1,10 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
+import { SdkClient } from "@azure-tools/typespec-client-generator-core";
+import { getDoc } from "@typespec/compiler";
+import { getServers } from "@typespec/http";
+import * as path from "path";
 import {
   buildRuntimeImports,
   Imports,
@@ -16,12 +20,8 @@ import {
   Schema,
   SchemaContext,
   transformSampleGroups,
-  UrlInfo
+  UrlInfo,
 } from "../rlc-common/index.js";
-import { SdkClient } from "@azure-tools/typespec-client-generator-core";
-import { getDoc } from "@typespec/compiler";
-import { getServers } from "@typespec/http";
-import * as path from "path";
 import { SdkContext } from "../utils/interfaces.js";
 import {
   getDefaultService,
@@ -29,20 +29,20 @@ import {
   getImportedModelName,
   getSchemaForType,
   getTypeName,
-  predictDefaultValue
-} from "../utils/modelUtils.js";
-import { getClientLroOverload } from "../utils/operationUtil.js";
-import { transformApiVersionInfo } from "./transformApiVersionInfo.js";
-import { transformHelperFunctionDetails } from "./transformHelperFunctionDetails.js";
-import { transformToParameterTypes } from "./transformParameters.js";
-import { transformPaths } from "./transformPaths.js";
-import { transformToResponseTypes } from "./transformResponses.js";
-import { transformSchemas } from "./transformSchemas.js";
-import { transformTelemetryInfo } from "./transformTelemetryInfo.js";
+  predictDefaultValue,
+} from "../utils/model-utils.js";
+import { getClientLroOverload } from "../utils/operation-util.js";
+import { transformApiVersionInfo } from "./transform-api-version-info.js";
+import { transformHelperFunctionDetails } from "./transform-helper-function-details.js";
+import { transformToParameterTypes } from "./transform-parameters.js";
+import { transformPaths } from "./transform-paths.js";
+import { transformToResponseTypes } from "./transform-responses.js";
+import { transformSchemas } from "./transform-schemas.js";
+import { transformTelemetryInfo } from "./transform-telemetry-info.js";
 
 export async function transformRLCModel(
   client: SdkClient,
-  dpgContext: SdkContext
+  dpgContext: SdkContext,
 ): Promise<RLCModel> {
   const program = dpgContext.program;
   const options: RLCOptions = dpgContext.rlcOptions!;
@@ -51,7 +51,7 @@ export async function transformRLCModel(
     dpgContext.generationPathDetail?.rlcSourcesDir ?? "",
     options.batch && options.batch.length > 1
       ? normalizeName(client.name.replace("Client", ""), NameType.File)
-      : ""
+      : "",
   );
   const libraryName = normalizeName(
     options.batch && (options.isModularLibrary || options.batch.length > 1)
@@ -60,28 +60,20 @@ export async function transformRLCModel(
           client.name ??
           getDefaultService(program, options.isModularLibrary)?.title ??
           ""),
-    NameType.Class
+    NameType.Class,
   );
   const importSet = initInternalImports();
   const urlInfo = transformUrlInfo(client, dpgContext, importSet);
   const paths: Paths = transformPaths(client, dpgContext, importSet);
   const schemas: Schema[] = transformSchemas(client, dpgContext);
-  const responses: OperationResponse[] = transformToResponseTypes(
-    client,
-    dpgContext,
-    importSet
-  );
+  const responses: OperationResponse[] = transformToResponseTypes(client, dpgContext, importSet);
   const parameters: OperationParameter[] = transformToParameterTypes(
     client,
     dpgContext,
     importSet,
-    urlInfo?.apiVersionInfo
-  );
-  const helperDetails = transformHelperFunctionDetails(
-    client,
-    dpgContext,
-    options.flavor
+    urlInfo?.apiVersionInfo,
   );
+  const helperDetails = transformHelperFunctionDetails(client, dpgContext, options.flavor);
   // Enrich client-level annotation detail
   helperDetails.clientLroOverload = getClientLroOverload(paths);
 
@@ -100,14 +92,13 @@ export async function transformRLCModel(
     telemetryOptions,
     importInfo: {
       internalImports: importSet,
-      runtimeImports: buildRuntimeImports(options.flavor)
+      runtimeImports: buildRuntimeImports(options.flavor),
     },
-    rlcSourceDir
+    rlcSourceDir,
   };
   model.sampleGroups = transformSampleGroups(
     model,
-    options?.generateSample ===
-      true /* Enable mock sample content if generateSample === true */
+    options?.generateSample === true /* Enable mock sample content if generateSample === true */,
   );
   options.generateSample =
     (options.generateSample === true || options.generateSample === undefined) &&
@@ -118,7 +109,7 @@ export async function transformRLCModel(
 export function transformUrlInfo(
   client: SdkClient,
   dpgContext: SdkContext,
-  importDetails: Imports
+  importDetails: Imports,
 ): UrlInfo | undefined {
   const importedModels = new Set<string>();
   const usage = [SchemaContext.Exception, SchemaContext.Input];
@@ -144,12 +135,9 @@ export function transformUrlInfo(
         const schema = getSchemaForType(dpgContext, type, {
           usage: usage,
           needRef: false,
-          relevantProperty: property
+          relevantProperty: property,
         });
-        getImportedModelName(schema, usage)?.forEach(
-          importedModels.add,
-          importedModels
-        );
+        getImportedModelName(schema, usage)?.forEach(importedModels.add, importedModels);
         const normName = normalizeName(key, NameType.Parameter, true);
         if (normName !== key && endpoint) {
           endpoint = endpoint.replace(`{${key}}`, `{${normName}}`);
@@ -162,7 +150,7 @@ export function transformUrlInfo(
             (getDoc(program, property) &&
               getFormattedPropertyDoc(program, property, schema, " ")) ??
             getFormattedPropertyDoc(program, type, schema, " " /* separator*/),
-          value: predictDefaultValue(dpgContext, host?.[0]?.parameters.get(key))
+          value: predictDefaultValue(dpgContext, host?.[0]?.parameters.get(key)),
         });
       }
     }
@@ -182,16 +170,16 @@ export function transformUrlInfo(
     }
   }
   // Set the default value if missing endpoint parameter
-  if (endpoint == undefined && urlParameters.length === 0) {
+  if (endpoint === undefined && urlParameters.length === 0) {
     endpoint = "{endpointParam}";
     urlParameters.push({
       name: "endpointParam",
-      type: "string"
+      type: "string",
     });
   }
   const apiVersionInfo = transformApiVersionInfo(client, dpgContext, {
     endpoint,
-    urlParameters
+    urlParameters,
   });
   if (
     apiVersionInfo &&
@@ -203,7 +191,7 @@ export function transformUrlInfo(
     urlParameters.push({
       oriName: "api-version",
       name: "apiVersion",
-      type: "string"
+      type: "string",
     });
   }
   return { endpoint, urlParameters, apiVersionInfo };