@azure-tools/typespec-ts 0.49.0 → 0.49.1

package/src/modular/serialization/buildDeserializerFunction.ts

@@ -12,6 +12,7 @@ import { SdkContext } from "../../utils/interfaces.js";
 import {
   getAllAncestors,
   getAllProperties,
+  getPropertySerializedName,
   getResponseMapping
 } from "../helpers/operationHelpers.js";
 import {
@@ -218,8 +219,12 @@ function buildPolymorphicDeserializer(
       `);
   });
 
+  // Use wire format name for the switch since item is raw JSON from the service
+  const discriminatorWireName = getPropertySerializedName(
+    type.discriminatorProperty
+  );
   statements.push(`
-      switch (item.${normalizeName(type.discriminatorProperty.name, NameType.Property)}) {
+      switch (item["${discriminatorWireName}"]) {
        ${cases.join("\n")}
         default:
           return item;
@@ -300,8 +305,12 @@ function buildDiscriminatedUnionDeserializer(
         return ${subtypeDeserializerName}(item as ${subTypeName});
     `);
   }
+  // Use wire format name for the switch since item is raw JSON from the service
+  const discriminatorWireName = type.discriminatorProperty
+    ? getPropertySerializedName(type.discriminatorProperty)
+    : "unknown";
   output.push(`
-    switch (item.${type.discriminatorProperty ? normalizeName(type.discriminatorProperty.name, NameType.Property) : "unknown"}) {
+    switch (item["${discriminatorWireName}"]) {
      ${cases.join("\n")}
       default:
         return ${baseDeserializerName}(item);

package/src/modular/serialization/buildXmlSerializerFunction.ts

@@ -29,8 +29,7 @@ import { NoTarget } from "@typespec/compiler";
 import { isMetadata } from "@typespec/http";
 import { normalizeModelPropertyName } from "../type-expressions/get-type-expression.js";
 import { isReadOnly } from "@azure-tools/typespec-client-generator-core";
-import { buildModelSerializer } from "./buildSerializerFunction.js";
-import { buildModelDeserializer } from "./buildDeserializerFunction.js";
+import { useDependencies } from "../../framework/hooks/useDependencies.js";
 
 /**
  * Checks if a model type has XML serialization options defined
@@ -172,6 +171,215 @@ export function buildXmlModelSerializer(
   return serializerFunction;
 }
 
+/**
+ * Builds an XML object serializer function for a model type.
+ * This serializer returns a plain object with XML property names (not an XML string).
+ * Used for nested objects within XML serialization.
+ */
+export function buildXmlObjectModelSerializer(
+  context: SdkContext,
+  type: SdkModelType,
+  options: ModelSerializeOptions = {
+    nameOnly: false,
+    skipDiscriminatedUnionSuffix: false
+  }
+): FunctionDeclarationStructure | string | undefined {
+  if (!isSupportedSerializeType(type)) {
+    return undefined;
+  }
+
+  if (!type.name) {
+    reportDiagnostic(context.program, {
+      code: "anonymous-type-serialization",
+      target: type.__raw || NoTarget
+    });
+    return undefined;
+  }
+
+  if (
+    !type.usage ||
+    (type.usage !== undefined &&
+      (type.usage & UsageFlags.Input) !== UsageFlags.Input)
+  ) {
+    return undefined;
+  }
+
+  if (isAzureCoreErrorType(context.program, type.__raw!)) {
+    return undefined;
+  }
+
+  const serializerFunctionName =
+    options.predefinedName ??
+    `${normalizeModelName(
+      context,
+      type,
+      NameType.Operation,
+      options.skipDiscriminatedUnionSuffix
+    )}XmlObjectSerializer`;
+
+  if (options.nameOnly) {
+    return resolveReference(refkey(type, "xmlObjectSerializer"));
+  }
+
+  const properties = getAllProperties(context, type, getAllAncestors(type));
+
+  // Build the object literal with XML property names
+  const propertyAssignments = buildXmlObjectPropertyAssignments(
+    context,
+    properties
+  );
+
+  const statements: string[] = [];
+
+  // Check if the model is a dictionary type (has additionalProperties)
+  // For Record<T> types, we need to spread the item properties
+  const isDictType = type.additionalProperties !== undefined;
+
+  if (isDictType && propertyAssignments.length === 0) {
+    // Pure dictionary type - spread all properties
+    statements.push(
+      `return { ...item } as ${resolveReference(XmlHelpers.XmlSerializedObject)};`
+    );
+  } else if (isDictType) {
+    // Model with both defined properties and additional properties
+    statements.push(`return {${propertyAssignments}, ...item};`);
+  } else {
+    statements.push(`return {${propertyAssignments}};`);
+  }
+
+  const xmlSerializedObjectRef = resolveReference(
+    XmlHelpers.XmlSerializedObject
+  );
+
+  // Use _item when there are no properties and not a dict type to avoid unused parameter lint error
+  const paramName =
+    propertyAssignments.length === 0 && !isDictType ? "_item" : "item";
+
+  const serializerFunction: FunctionDeclarationStructure = {
+    kind: StructureKind.Function,
+    name: serializerFunctionName,
+    isExported: true,
+    parameters: [
+      {
+        name: paramName,
+        type: resolveReference(refkey(type))
+      }
+    ],
+    returnType: xmlSerializedObjectRef,
+    statements
+  };
+
+  return serializerFunction;
+}
+
+/**
+ * Builds the property assignments for XML object serializer.
+ * Maps client property names to XML property names in the output object.
+ */
+function buildXmlObjectPropertyAssignments(
+  context: SdkContext,
+  properties: SdkModelPropertyType[]
+): string {
+  const assignments: string[] = [];
+
+  for (const property of properties) {
+    if (property.kind !== "property") {
+      continue;
+    }
+    if (isReadOnly(property)) {
+      continue;
+    }
+    if (isMetadata(context.program, property.__raw!)) {
+      continue;
+    }
+
+    const xmlOptions = property.serializationOptions?.xml;
+    const propertyName = normalizeModelPropertyName(context, property);
+    const cleanPropertyName = propertyName.replace(/^"|"$/g, "");
+
+    // Use XML name if available, fall back to serializedName, then JSON name, then property name
+    const xmlName = xmlOptions?.name ?? property.name;
+
+    // Handle nested objects and arrays
+    const nestedSerializer = getNestedXmlSerializer(context, property.type);
+
+    let valueExpr: string;
+    if (nestedSerializer && property.type.kind === "model") {
+      // Nested object - use XML object serializer
+      valueExpr = `item["${cleanPropertyName}"] !== undefined ? ${nestedSerializer}(item["${cleanPropertyName}"]) : undefined`;
+    } else if (
+      nestedSerializer &&
+      property.type.kind === "array" &&
+      property.type.valueType.kind === "model"
+    ) {
+      // Array of objects - map each item through XML object serializer
+      valueExpr = `item["${cleanPropertyName}"]?.map((i: any) => ${nestedSerializer}(i))`;
+    } else {
+      // Handle type-specific serialization
+      valueExpr = buildXmlValueSerializationExpr(
+        context,
+        property.type,
+        `item["${cleanPropertyName}"]`
+      );
+    }
+
+    assignments.push(`"${xmlName}": ${valueExpr}`);
+  }
+
+  return assignments.join(",\n    ");
+}
+
+/**
+ * Builds the serialization expression for a value based on its type.
+ * Handles bytes (base64), dates, and arrays of these types.
+ */
+function buildXmlValueSerializationExpr(
+  context: SdkContext,
+  type: SdkType,
+  valueExpr: string
+): string {
+  const uint8ArrayToStringRef = resolveReference(
+    useDependencies().uint8ArrayToString
+  );
+
+  switch (type.kind) {
+    case "bytes":
+      // Convert Uint8Array to base64 string
+      return `${valueExpr} !== undefined ? ${uint8ArrayToStringRef}(${valueExpr}, "base64") : undefined`;
+
+    case "utcDateTime": {
+      // Convert Date to appropriate string format
+      const encoding = (type.encode as string) ?? "rfc3339";
+      if (encoding === "unixTimestamp") {
+        return `${valueExpr} !== undefined ? ${valueExpr}.getTime() : undefined`;
+      } else if (encoding === "rfc7231") {
+        return `${valueExpr} !== undefined ? ${valueExpr}.toUTCString() : undefined`;
+      }
+      // Default rfc3339
+      return `${valueExpr} !== undefined ? ${valueExpr}.toISOString() : undefined`;
+    }
+
+    case "array": {
+      // Handle arrays - need to serialize each element
+      const itemExpr = buildXmlValueSerializationExpr(
+        context,
+        type.valueType,
+        "i"
+      );
+      if (itemExpr !== "i") {
+        // If items need transformation, map them
+        return `${valueExpr}?.map((i: any) => ${itemExpr})`;
+      }
+      // No transformation needed
+      return valueExpr;
+    }
+
+    default:
+      // Primitive types - use directly
+      return valueExpr;
+  }
+}
+
 /**
  * Builds the property metadata array for XML serialization
  */
@@ -214,6 +422,12 @@ function buildPropertyMetadataArray(
     if (typeInfo.dateEncoding) {
       metadataObj.push(`dateEncoding: "${typeInfo.dateEncoding}"`);
     }
+    if (typeInfo.bytesEncoding) {
+      metadataObj.push(`bytesEncoding: "${typeInfo.bytesEncoding}"`);
+    }
+    if (typeInfo.itemType) {
+      metadataObj.push(`itemType: "${typeInfo.itemType}"`);
+    }
 
     // Add serializer for complex types
     const nestedSerializer = getNestedXmlSerializer(context, property.type);
@@ -273,10 +487,30 @@ function buildXmlOptionsString(xmlOptions?: {
 function getPropertyTypeInfo(type: SdkType): {
   type?: "array" | "object" | "primitive" | "date" | "bytes" | "dict";
   dateEncoding?: "rfc3339" | "rfc7231" | "unixTimestamp";
+  bytesEncoding?: "base64" | "base64url";
+  itemType?: "primitive" | "date" | "bytes";
 } {
   switch (type.kind) {
-    case "array":
-      return { type: "array" };
+    case "array": {
+      // For arrays, also extract item type info for bytes/date items
+      const itemInfo = getPropertyTypeInfo(type.valueType);
+      const result: ReturnType<typeof getPropertyTypeInfo> = { type: "array" };
+      // Only include item type info for types that need special serialization
+      if (
+        itemInfo.type === "bytes" ||
+        itemInfo.type === "date" ||
+        itemInfo.type === "primitive"
+      ) {
+        result.itemType = itemInfo.type as "primitive" | "date" | "bytes";
+      }
+      if (itemInfo.dateEncoding) {
+        result.dateEncoding = itemInfo.dateEncoding;
+      }
+      if (itemInfo.bytesEncoding) {
+        result.bytesEncoding = itemInfo.bytesEncoding;
+      }
+      return result;
+    }
     case "model":
       return { type: "object" };
     case "dict":
@@ -287,24 +521,30 @@ function getPropertyTypeInfo(type: SdkType): {
         dateEncoding:
           (type.encode as "rfc3339" | "rfc7231" | "unixTimestamp") ?? "rfc3339"
       };
-    case "bytes":
-      return { type: "bytes" };
+    case "bytes": {
+      const encode = (type as any).encode as string | undefined;
+      // Default to base64 if no encoding specified
+      const bytesEncoding =
+        encode === "base64url" ? "base64url" : ("base64" as const);
+      return { type: "bytes", bytesEncoding };
+    }
     default:
       return { type: "primitive" };
   }
 }
 
 /**
- * Gets the nested XML serializer function reference for complex types
+ * Gets the nested XML serializer function reference for complex types.
+ * Uses the XML object serializer to properly handle XML property names.
  */
 function getNestedXmlSerializer(
   context: SdkContext,
   type: SdkType
 ): string | undefined {
   if (type.kind === "model") {
-    // For nested objects, use the regular JSON serializer which returns objects
-    // The XML builder will convert these objects to XML elements
-    const serializerName = buildModelSerializer(context, type, {
+    // For nested objects, use the XML object serializer which returns objects
+    // with XML property names for proper serialization
+    const serializerName = buildXmlObjectModelSerializer(context, type, {
       nameOnly: true,
       skipDiscriminatedUnionSuffix: false
     });
@@ -313,12 +553,16 @@ function getNestedXmlSerializer(
     }
   }
   if (type.kind === "array" && type.valueType.kind === "model") {
-    // For arrays, use the regular JSON serializer which returns objects
+    // For arrays, use the XML object serializer for items
     // The XML helper calls this for each item and handles the array mapping
-    const itemSerializer = buildModelSerializer(context, type.valueType, {
-      nameOnly: true,
-      skipDiscriminatedUnionSuffix: false
-    });
+    const itemSerializer = buildXmlObjectModelSerializer(
+      context,
+      type.valueType,
+      {
+        nameOnly: true,
+        skipDiscriminatedUnionSuffix: false
+      }
+    );
     if (typeof itemSerializer === "string") {
       return itemSerializer;
     }
@@ -465,6 +709,12 @@ function buildDeserializePropertyMetadataArray(
     if (typeInfo.dateEncoding) {
       metadataObj.push(`dateEncoding: "${typeInfo.dateEncoding}"`);
     }
+    if (typeInfo.bytesEncoding) {
+      metadataObj.push(`bytesEncoding: "${typeInfo.bytesEncoding}"`);
+    }
+    if (typeInfo.itemType) {
+      metadataObj.push(`itemType: "${typeInfo.itemType}"`);
+    }
 
     // Add deserializer for complex types
     const nestedDeserializer = getNestedXmlDeserializer(context, property.type);
@@ -479,16 +729,17 @@ function buildDeserializePropertyMetadataArray(
 }
 
 /**
- * Gets the nested XML deserializer function reference for complex types
+ * Gets the nested XML deserializer function reference for complex types.
+ * Uses the XML object deserializer to properly handle XML property names.
  */
 function getNestedXmlDeserializer(
   context: SdkContext,
   type: SdkType
 ): string | undefined {
   if (type.kind === "model") {
-    // For nested objects, use the regular JSON deserializer which takes parsed objects
-    // The XML parser has already converted the XML to an object structure
-    const deserializerName = buildModelDeserializer(context, type, {
+    // For nested objects, use the XML object deserializer which takes parsed XML objects
+    // and uses XML property names for mapping
+    const deserializerName = buildXmlObjectModelDeserializer(context, type, {
       nameOnly: true,
       skipDiscriminatedUnionSuffix: false
     });
@@ -497,15 +748,115 @@ function getNestedXmlDeserializer(
     }
   }
   if (type.kind === "array" && type.valueType.kind === "model") {
-    // For arrays, use the regular JSON deserializer which takes parsed objects
+    // For arrays, use the XML object deserializer for items
     // The XML helper calls this for each item and handles the array mapping
-    const itemDeserializer = buildModelDeserializer(context, type.valueType, {
-      nameOnly: true,
-      skipDiscriminatedUnionSuffix: false
-    });
+    const itemDeserializer = buildXmlObjectModelDeserializer(
+      context,
+      type.valueType,
+      {
+        nameOnly: true,
+        skipDiscriminatedUnionSuffix: false
+      }
+    );
     if (typeof itemDeserializer === "string") {
       return itemDeserializer;
     }
   }
   return undefined;
 }
+
+/**
+ * Builds an XML object deserializer function for a model type.
+ * This deserializer takes a pre-parsed XML object (not an XML string)
+ * and uses XML property names for mapping. Used for nested objects.
+ */
+export function buildXmlObjectModelDeserializer(
+  context: SdkContext,
+  type: SdkModelType,
+  options: ModelSerializeOptions = {
+    nameOnly: false,
+    skipDiscriminatedUnionSuffix: false
+  }
+): FunctionDeclarationStructure | string | undefined {
+  if (!isSupportedSerializeType(type)) {
+    return undefined;
+  }
+
+  if (!type.name) {
+    reportDiagnostic(context.program, {
+      code: "anonymous-type-deserialization",
+      target: type.__raw || NoTarget
+    });
+    return undefined;
+  }
+
+  if (
+    !type.usage ||
+    (type.usage !== undefined &&
+      (type.usage & UsageFlags.Output) !== UsageFlags.Output &&
+      (type.usage & UsageFlags.Exception) !== UsageFlags.Exception)
+  ) {
+    return undefined;
+  }
+
+  if (isAzureCoreErrorType(context.program, type.__raw!)) {
+    return undefined;
+  }
+
+  const deserializerFunctionName =
+    options.predefinedName ??
+    `${normalizeModelName(
+      context,
+      type,
+      NameType.Operation,
+      options.skipDiscriminatedUnionSuffix
+    )}XmlObjectDeserializer`;
+
+  if (options.nameOnly) {
+    return resolveReference(refkey(type, "xmlObjectDeserializer"));
+  }
+
+  const deserializeXmlObjectRef = resolveReference(
+    XmlHelpers.deserializeXmlObject
+  );
+  const xmlPropertyDeserializeMetadataRef = resolveReference(
+    XmlHelpers.XmlPropertyDeserializeMetadata
+  );
+
+  const properties = getAllProperties(context, type, getAllAncestors(type));
+
+  // Build property metadata array for deserialization
+  const propertyMetadata = buildDeserializePropertyMetadataArray(
+    context,
+    properties
+  );
+
+  const statements: string[] = [];
+
+  // Generate the properties metadata constant
+  statements.push(
+    `const properties: ${xmlPropertyDeserializeMetadataRef}[] = [${propertyMetadata}];`
+  );
+
+  // Generate the deserialization call - no rootName needed for object deserializer
+  const typeRef = resolveReference(refkey(type));
+  statements.push(
+    `return ${deserializeXmlObjectRef}<${typeRef}>(xmlObject, properties);`
+  );
+
+  const deserializerFunction: FunctionDeclarationStructure = {
+    kind: StructureKind.Function,
+    name: deserializerFunctionName,
+    isExported: true,
+    parameters: [
+      {
+        name: "xmlObject",
+        type: "Record<string, unknown>"
+      }
+    ],
+    returnType: resolveReference(refkey(type)),
+    statements
+  };
+
+  return deserializerFunction;
+}

package/src/modular/static-helpers-metadata.ts

@@ -209,6 +209,11 @@ export const XmlHelpers = {
     name: "deserializeFromXml",
     location: "serialization/xml-helpers.ts"
   },
+  deserializeXmlObject: {
+    kind: "function",
+    name: "deserializeXmlObject",
+    location: "serialization/xml-helpers.ts"
+  },
   isXmlContentType: {
     kind: "function",
     name: "isXmlContentType",
@@ -218,5 +223,10 @@ export const XmlHelpers = {
     kind: "function",
     name: "isJsonContentType",
     location: "serialization/xml-helpers.ts"
+  },
+  XmlSerializedObject: {
+    kind: "interface",
+    name: "XmlSerializedObject",
+    location: "serialization/xml-helpers.ts"
   }
 } as const;

package/src/modular/type-expressions/get-model-expression.ts

@@ -4,12 +4,17 @@ import {
   normalizeModelPropertyName
 } from "./get-type-expression.js";
 
-import { SdkModelType } from "@azure-tools/typespec-client-generator-core";
+import {
+  SdkModelPropertyType,
+  SdkModelType,
+  SdkServiceResponseHeader
+} from "@azure-tools/typespec-client-generator-core";
 import { refkey } from "../../framework/refkey.js";
 import { resolveReference } from "../../framework/reference.js";
 import { shouldEmitInline } from "./utils.js";
 import { useContext } from "../../contextManager.js";
 import { SdkContext } from "../../utils/interfaces.js";
+import { MultipartHelpers } from "../static-helpers-metadata.js";
 
 export interface ModelExpressionOptions extends EmitTypeOptions {
   skipPolymorphicUnion?: boolean;
@@ -26,18 +31,7 @@ export function getModelExpression(
   }
 
   if (shouldEmitInline(type, options)) {
-    // generate Record<string, any> for empty anonymous object
-    if (type.properties.length === 0) {
-      return "Record<string, any>";
-    }
-    return `{
-      ${type.properties
-        .map(
-          (p) =>
-            `${normalizeModelPropertyName(context, p)}${p.optional ? "?" : ""}: ${getTypeExpression(context, p.type)}`
-        )
-        .join(",\n")}
-    }`;
+    return emitInlineModel(context, type.properties);
   } else {
     if (!options.skipPolymorphicUnion && type.discriminatedSubtypes) {
       return resolveReference(refkey(type, "polymorphicType"));
@@ -52,6 +46,77 @@ const externalModels: Record<string, string> = {
   "Azure.Core.Foundations.ErrorResponse": "AzureCoreErrorResponse"
 };
 
+export function emitInlineModel(
+  context: SdkContext,
+  properties: (SdkModelPropertyType | SdkServiceResponseHeader)[]
+): string {
+  // generate Record<string, any> for empty anonymous object
+  if (properties.length === 0) {
+    return "Record<string, any>";
+  }
+  return `{
+      ${properties
+        .map(
+          (p) =>
+            `${normalizeModelPropertyName(context, p)}${p.optional ? "?" : ""}: ${getPropertyTypeExpression(context, p)}`
+        )
+        .join(",\n")}
+    }`;
+}
+
+function getPropertyTypeExpression(
+  context: SdkContext,
+  property: SdkModelPropertyType | SdkServiceResponseHeader
+): string {
+  if (
+    property.kind === "property" &&
+    property.serializationOptions.multipart?.isFilePart
+  ) {
+    return getMultipartFileTypeExpression(context, property);
+  }
+  return getTypeExpression(context, property.type);
+}
+
+export function getMultipartFileTypeExpression(
+  context: SdkContext,
+  property: SdkModelPropertyType
+): string {
+  const multipartOptions = property.serializationOptions.multipart;
+
+  const isContentTypeOptional =
+    multipartOptions?.contentType === undefined ||
+    multipartOptions.contentType.optional ||
+    multipartOptions.defaultContentTypes.length > 0;
+  const isFilenameOptional =
+    multipartOptions?.filename === undefined ||
+    multipartOptions.filename.optional;
+
+  const contentTypeType = multipartOptions?.contentType
+    ? getTypeExpression(context, multipartOptions.contentType.type)
+    : "string";
+  const filenameType = multipartOptions?.filename
+    ? getTypeExpression(context, multipartOptions.filename.type)
+    : "string";
+
+  let typeExpression = "{";
+  typeExpression += `contents: ${resolveReference(MultipartHelpers.FileContents)};`;
+  typeExpression += `contentType${isContentTypeOptional ? "?" : ""}: ${contentTypeType};`;
+  typeExpression += `filename${isFilenameOptional ? "?" : ""}: ${filenameType};`;
+  typeExpression += "}";
+
+  if (isContentTypeOptional && isFilenameOptional) {
+    typeExpression = `(${resolveReference(MultipartHelpers.FileContents)}) | ${typeExpression}`;
+  } else {
+    typeExpression = `File | ${typeExpression}`;
+  }
+
+  if (property.type.kind === "array") {
+    typeExpression = `Array<${typeExpression}>`;
+  }
+
+  return typeExpression;
+}
+
 export function getExternalModel(type: SdkModelType) {
   const commonName = externalModels[type.crossLanguageDefinitionId];
 

package/src/modular/type-expressions/get-nullable-expression.ts

@@ -10,7 +10,16 @@ export function getNullableExpression(
   options: EmitTypeOptions = {}
 ): string {
   if (shouldEmitInline(type, options)) {
+    // Check if we should ignore null for optional properties
+    const ignoreNullableOnOptional =
+      context.rlcOptions?.ignoreNullableOnOptional ?? false;
+    const isOptional = options.isOptional ?? false;
+
     const nonNullableType = getTypeExpression(context, type.type, options);
+    // If the property is optional and we should ignore nullable, just return the non-nullable type
+    if (ignoreNullableOnOptional && isOptional) {
+      return nonNullableType;
+    }
     return `(${nonNullableType}) | null`;
   } else {
     return resolveReference(type);

package/src/modular/type-expressions/get-type-expression.ts

@@ -1,6 +1,7 @@
 import {
   SdkHttpParameter,
   SdkModelPropertyType,
+  SdkServiceResponseHeader,
   SdkType
 } from "@azure-tools/typespec-client-generator-core";
 import { getCredentialExpression } from "./get-credential-expression.js";
@@ -13,11 +14,12 @@ import { getNullableExpression } from "./get-nullable-expression.js";
 
 export interface EmitTypeOptions {
   emitInline?: boolean;
+  isOptional?: boolean;
 }
 
 export function normalizeModelPropertyName(
   context: SdkContext,
-  property: SdkModelPropertyType | SdkHttpParameter
+  property: SdkModelPropertyType | SdkHttpParameter | SdkServiceResponseHeader
 ): string {
   const normalizedPropName = normalizeName(property.name, NameType.Property);
   return context.rlcOptions?.ignorePropertyNameNormalize