@azure-tools/typespec-ts 0.28.0 → 0.29.0

package/src/transform/transformResponses.ts

@@ -15,7 +15,7 @@ import {
   getLroLogicalResponseName,
   Imports
 } from "@azure-tools/rlc-common";
-import { getDoc, ignoreDiagnostics } from "@typespec/compiler";
+import { getDoc, ignoreDiagnostics, isVoidType } from "@typespec/compiler";
 import {
   getHttpOperation,
   HttpOperation,
@@ -174,7 +174,7 @@ function transformBody(
   let fromCore = false;
   for (const data of response.responses) {
     const body = data?.body;
-    if (!body) {
+    if (!body || isVoidType(body.type)) {
       continue;
     }
     const hasBinaryContent = body.contentTypes.some((contentType) =>

package/src/transform/transformSchemas.ts

@@ -27,9 +27,9 @@ export function transformSchemas(client: SdkClient, dpgContext: SdkContext) {
     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[]>();
-  const modelKey = Symbol("typescript-models-" + client.name);
   const clientOperations = listOperationsInOperationGroup(dpgContext, client);
   for (const clientOp of clientOperations) {
     const route = ignoreDiagnostics(getHttpOperation(program, clientOp));
@@ -77,7 +77,7 @@ export function transformSchemas(client: SdkClient, dpgContext: SdkContext) {
       getGeneratedModels(bodyModel, SchemaContext.Input);
     }
     for (const resp of route.responses) {
-      if (isAzureCoreErrorType(resp.type)) {
+      if (isAzureCoreErrorType(dpgContext.program, resp.type)) {
         continue;
       }
       for (const resps of resp.responses) {
@@ -87,12 +87,11 @@ export function transformSchemas(client: SdkClient, dpgContext: SdkContext) {
             getGeneratedModels(value, SchemaContext.Output);
           }
         }
-
-        const respModel = resps.body;
+        const respModel = resps?.body?.type;
         if (!respModel) {
           continue;
         }
-        getGeneratedModels(respModel.type, SchemaContext.Output);
+        getGeneratedModels(respModel, SchemaContext.Output);
       }
     }
   }
@@ -112,7 +111,7 @@ export function transformSchemas(client: SdkClient, dpgContext: SdkContext) {
     }
   }
   transformHostParameters();
-  program.stateMap(modelKey).forEach((context, tspModel) => {
+  usageMap.forEach((context, tspModel) => {
     const model = getSchemaForType(dpgContext, tspModel, {
       usage: context,
       isRequestBody: requestBodySet.has(tspModel),
@@ -127,22 +126,19 @@ export function transformSchemas(client: SdkClient, dpgContext: SdkContext) {
     }
     const pureModel = JSON.stringify(trimUsage(model));
     schemaMap.set(pureModel, model);
-    let usage = schemas.get(pureModel) ?? [];
-    if (!usage?.includes(context)) {
-      usage = usage.concat(context as SchemaContext[]);
-    }
-    schemas.set(pureModel, usage);
+    const usageSet = new Set((schemas.get(pureModel) ?? []).concat(context));
+    schemas.set(pureModel, Array.from(usageSet));
   });
 
   function setModelMap(type: Type, schemaContext: SchemaContext) {
-    if (program.stateMap(modelKey).get(type)) {
-      const context = program.stateMap(modelKey).get(type);
+    if (usageMap.get(type)) {
+      const context = usageMap.get(type);
       if (context && context.indexOf(schemaContext) === -1) {
         context.push(schemaContext);
-        program.stateMap(modelKey).set(type, context);
+        usageMap.set(type, context);
       }
     } else {
-      program.stateMap(modelKey).set(type, [schemaContext]);
+      usageMap.set(type, [schemaContext]);
     }
   }
   function getGeneratedModels(model: Type, context: SchemaContext) {
@@ -151,21 +147,18 @@ export function transformSchemas(client: SdkClient, dpgContext: SdkContext) {
       const indexer = (model as Model).indexer;
       if (
         indexer?.value &&
-        (!program.stateMap(modelKey).get(indexer?.value) ||
-          !program
-            .stateMap(modelKey)
-            .get(indexer?.value)
-            ?.includes(context))
+        (!usageMap.get(indexer?.value) ||
+          !usageMap.get(indexer?.value)?.includes(context))
       ) {
         getGeneratedModels(indexer.value, context);
       }
       for (const prop of model.properties) {
         const [, propType] = prop;
-        if (program.stateMap(modelKey).get(propType.type)?.includes(context)) {
+        if (usageMap.get(propType.type)?.includes(context)) {
           continue;
         }
         if (propType.type.kind === "Model") {
-          if (isAzureCoreErrorType(propType.type)) {
+          if (isAzureCoreErrorType(dpgContext.program, propType.type)) {
             continue;
           }
           getGeneratedModels(propType.type, context);
@@ -176,11 +169,8 @@ export function transformSchemas(client: SdkClient, dpgContext: SdkContext) {
               (variant.type.kind === "Model" ||
                 variant.type.kind === "Union" ||
                 variant.type.kind === "Enum") &&
-              (!program.stateMap(modelKey).get(variant.type) ||
-                !program
-                  .stateMap(modelKey)
-                  .get(variant.type)
-                  ?.includes(context))
+              (!usageMap.get(variant.type) ||
+                !usageMap.get(variant.type)?.includes(context))
             ) {
               getGeneratedModels(variant.type, context);
             }
@@ -197,8 +187,8 @@ export function transformSchemas(client: SdkClient, dpgContext: SdkContext) {
       if (
         baseModel &&
         baseModel.kind === "Model" &&
-        (!program.stateMap(modelKey).get(baseModel) ||
-          !program.stateMap(modelKey).get(baseModel)?.includes(context))
+        (!usageMap.get(baseModel) ||
+          !usageMap.get(baseModel)?.includes(context))
       ) {
         getGeneratedModels(baseModel, context);
       }
@@ -210,8 +200,7 @@ export function transformSchemas(client: SdkClient, dpgContext: SdkContext) {
       for (const child of derivedModels) {
         if (
           child.kind === "Model" &&
-          (!program.stateMap(modelKey).get(child) ||
-            !program.stateMap(modelKey).get(child)?.includes(context))
+          (!usageMap.get(child) || !usageMap.get(child)?.includes(context))
         ) {
           getGeneratedModels(child, context);
         }
@@ -221,8 +210,8 @@ export function transformSchemas(client: SdkClient, dpgContext: SdkContext) {
       for (const variant of variants) {
         if (
           (variant.type.kind === "Model" || variant.type.kind === "Union") &&
-          (!program.stateMap(modelKey).get(variant.type) ||
-            !program.stateMap(modelKey).get(variant.type)?.includes(context))
+          (!usageMap.get(variant.type) ||
+            !usageMap.get(variant.type)?.includes(context))
         ) {
           getGeneratedModels(variant.type, context);
         }

package/src/transform/transfromRLCOptions.ts

@@ -85,7 +85,8 @@ function extractRLCOptions(
     sourceFrom: "TypeSpec",
     enableOperationGroup,
     enableModelNamespace,
-    hierarchyClient
+    hierarchyClient,
+    azureArm: dpgContext.arm
   };
 }
 
@@ -129,6 +130,14 @@ function processAuth(program: Program) {
               target: NoTarget
             });
           }
+          // ignore the user_impersonation scope
+          if (
+            flow.scopes.length === 1 &&
+            flow.scopes[0] &&
+            flow.scopes[0].value.toLowerCase() === "user_impersonation"
+          ) {
+            return securityInfo;
+          }
           securityInfo.credentialScopes.push(
             ...flow.scopes.map((item) => {
               return item.value;

package/src/utils/modelUtils.ts

@@ -231,7 +231,10 @@ export function getSchemaForType(
   }
   reportDiagnostic(program, {
     code: "invalid-schema",
-    format: { type: type.kind },
+    format: {
+      type: type.kind,
+      property: options?.relevantProperty?.name ?? ""
+    },
     target: type
   });
   return undefined;
@@ -242,18 +245,13 @@ export function getEffectiveModelFromType(program: Program, type: Type): Type {
    * set of properties when non-schema properties are excluded.
    */
   if (type.kind === "Model" && type.name === "") {
-    const effective = getEffectiveModelType(program, type, isSchemaProperty);
+    const effective = getEffectiveModelType(program, type, (property) =>
+      isSchemaProperty(program, property)
+    );
     if (effective.name) {
       return effective;
     }
   }
-  function isSchemaProperty(property: ModelProperty) {
-    const headerInfo = getHeaderFieldName(program, property);
-    const queryInfo = getQueryParamName(program, property);
-    const pathInfo = getPathParamName(program, property);
-    const statusCodeInfo = isStatusCode(program, property);
-    return !(headerInfo || queryInfo || pathInfo || statusCodeInfo);
-  }
   return type;
 }
 export function includeDerivedModel(
@@ -554,19 +552,6 @@ function validateDiscriminator(
   }
   return retVals.every((v) => v);
 }
-/**
- * A "schema property" here is a property that is emitted to OpenAPI schema.
- *
- * Headers, parameters, status codes are not schema properties even they are
- * represented as properties in typespec.
- */
-function isSchemaProperty(program: Program, property: ModelProperty) {
-  const headerInfo = getHeaderFieldName(program, property);
-  const queryInfo = getQueryParamName(program, property);
-  const pathInfo = getPathParamName(program, property);
-  const statusCodeinfo = isStatusCode(program, property);
-  return !(headerInfo || queryInfo || pathInfo || statusCodeinfo);
-}
 
 function getSchemaForModel(
   dpgContext: SdkContext,
@@ -617,7 +602,7 @@ function getSchemaForModel(
 
   const isMultipartBody = isMediaTypeMultipartFormData(contentTypes ?? []);
 
-  const isCoreModel = isAzureCoreErrorType(model);
+  const isCoreModel = isAzureCoreErrorType(program, model);
   const modelSchema: ObjectSchema = {
     name: isCoreModel
       ? name
@@ -819,20 +804,24 @@ function getSchemaForModel(
   }
 
   if (model.baseModel) {
-    modelSchema.parents = {
-      all: [
-        getSchemaForType(dpgContext, model.baseModel, {
-          usage,
-          needRef: true
-        })
-      ],
-      immediate: [
-        getSchemaForType(dpgContext, model.baseModel, {
-          usage,
-          needRef: true
-        })
-      ]
-    };
+    if (modelSchema.parents === undefined) {
+      modelSchema.parents = {
+        all: [],
+        immediate: []
+      };
+    }
+    modelSchema.parents.all?.push(
+      getSchemaForType(dpgContext, model.baseModel, {
+        usage,
+        needRef: true
+      })
+    );
+    modelSchema.parents.immediate?.push(
+      getSchemaForType(dpgContext, model.baseModel, {
+        usage,
+        needRef: true
+      })
+    );
   }
   return modelSchema;
 }
@@ -1337,11 +1326,7 @@ export function getSerializeTypeName(
     "Date | string",
     "string"
   );
-  const canSerialize = schema.enum
-    ? schema.enum.every((type) => {
-        return isSerializable(type) || type.type === "null";
-      })
-    : isSerializable(schema);
+  const canSerialize = isSerializable(schema);
   if (canSerialize) {
     return schema.alias ? typeName : formattedName;
   }
@@ -1352,6 +1337,11 @@ export function getSerializeTypeName(
   });
   return "string";
   function isSerializable(type: any) {
+    if (type.enum) {
+      return type.enum.every((i: any) => {
+        return isSerializable(i) || i.type === "null";
+      });
+    }
     return (
       ["string", "number", "boolean"].includes(type.type) || type.isConstant
     );
@@ -1582,16 +1572,40 @@ export function trimUsage(model: any) {
   return ordered;
 }
 
-export function isAzureCoreErrorType(t?: Type): boolean {
+export function buildCoreTypeInfo(program: Program, t?: Type) {
+  return isAzureCoreErrorType(program, t)
+    ? "ErrorType"
+    : isAzureCoreLroType(t)
+      ? "LroType"
+      : undefined;
+}
+
+export function isAzureCoreErrorType(program: Program, t?: Type): boolean {
+  if (!t || t.kind !== "Model") {
+    return false;
+  }
+  const effective = getEffectiveSchemaType(program, t);
   if (
-    t?.kind !== "Model" ||
-    !["error", "errorresponse", "innererror"].includes(t.name.toLowerCase())
+    !["error", "errorresponse", "innererror"].includes(
+      effective.name.toLowerCase()
+    )
   )
     return false;
+  return isAzureCoreFoundationsNamespace(effective);
+}
+
+// Check if the type in the Azure.Core.Foundations has an LRO type in core
+export function isAzureCoreLroType(t?: Type): boolean {
+  if (t?.kind !== "Enum" || !["operationstate"].includes(t.name.toLowerCase()))
+    return false;
+  return isAzureCoreFoundationsNamespace(t);
+}
+
+function isAzureCoreFoundationsNamespace(t?: Type): boolean {
   const namespaces = ".Azure.Core.Foundations".split(".");
   while (
     namespaces.length > 0 &&
-    (t?.kind === "Model" || t?.kind === "Namespace") &&
+    (t?.kind === "Model" || t?.kind === "Enum" || t?.kind === "Namespace") &&
     t.namespace?.name === namespaces.pop()
   ) {
     t = t.namespace;
@@ -1699,3 +1713,50 @@ function getMultipartInlineSignature(
 
   return `FormData | Array<${types}>`;
 }
+
+/**
+ * A "schema property" here is a property that is emitted to OpenAPI schema.
+ *
+ * Headers, parameters, status codes are not schema properties even they are
+ * represented as properties in typespec.
+ */
+export function isSchemaProperty(
+  program: Program,
+  property: ModelProperty
+): boolean {
+  const headerInfo = getHeaderFieldName(program, property);
+  const queryInfo = getQueryParamName(program, property);
+  const pathInfo = getPathParamName(program, property);
+  const statusCodeInfo = isStatusCode(program, property);
+  return !(headerInfo || queryInfo || pathInfo || statusCodeInfo);
+}
+
+export function getEffectiveSchemaType(
+  program: Program,
+  type: Model | Union
+): Model {
+  // If type is an anonymous model, tries to find a named model that has the same properties
+  let effective: Model | undefined = undefined;
+  if (type.kind === "Union") {
+    const nonNullOptions = [...type.variants.values()]
+      .map((x) => x.type)
+      .filter((t) => !isNullType(t));
+    if (
+      nonNullOptions.length === 1 &&
+      nonNullOptions[0]?.kind === "Model" &&
+      nonNullOptions[0]?.name === ""
+    ) {
+      effective = getEffectiveModelType(program, nonNullOptions[0]);
+    }
+    return type as any;
+  } else if (type.name === "") {
+    effective = getEffectiveModelType(program, type, (property) =>
+      isSchemaProperty(program, property)
+    );
+  }
+
+  if (effective?.name) {
+    return effective;
+  }
+  return type as Model;
+}