@azure-tools/typespec-ts 0.48.0 → 0.48.1-alpha.20260127.1

package/dist/src/modular/helpers/operationHelpers.js

@@ -1,15 +1,16 @@
 import { StructureKind } from "ts-morph";
 import { NoTarget } from "@typespec/compiler";
-import { PagingHelpers, PollingHelpers, SerializationHelpers, UrlTemplateHelpers } from "../static-helpers-metadata.js";
+import { PagingHelpers, PollingHelpers, SerializationHelpers, UrlTemplateHelpers, XmlHelpers } from "../static-helpers-metadata.js";
 import { getNullableValidType, isSpreadBodyParameter, isTypeNullable } from "./typeHelpers.js";
 import { getClassicalLayerPrefix, getOperationName } from "./namingHelpers.js";
-import { getCollectionFormatHelper, hasCollectionFormatInfo, isBinaryPayload, getCollectionFormatParseHelper, getCollectionFormatFromArrayEncoding, KnownCollectionFormat } from "../../utils/operationUtil.js";
+import { getCollectionFormatHelper, hasCollectionFormatInfo, isBinaryPayload, isXmlPayload, isMultipartPayload, hasDualFormatSupport, getCollectionFormatParseHelper, getCollectionFormatFromArrayEncoding, KnownCollectionFormat } from "../../utils/operationUtil.js";
 import { getPropertyWithOverrides, isNormalUnion, isSpecialHandledUnion } from "../serialization/serializeUtils.js";
 import { getDocsFromDescription, getFixmeForMultilineDocs } from "./docsHelpers.js";
 import { AzurePollingDependencies } from "../external-dependencies.js";
 import { NameType, normalizeName } from "@azure-tools/rlc-common";
 import { buildModelDeserializer, buildPropertyDeserializer } from "../serialization/buildDeserializerFunction.js";
 import { buildModelSerializer, buildPropertySerializer } from "../serialization/buildSerializerFunction.js";
+import { buildXmlModelSerializer, buildXmlModelDeserializer, hasXmlSerialization } from "../serialization/buildXmlSerializerFunction.js";
 import { refkey } from "../../framework/refkey.js";
 import { reportDiagnostic } from "../../lib.js";
 import { resolveReference } from "../../framework/reference.js";
@@ -20,6 +21,7 @@ import { getTypeExpression, normalizeModelPropertyName } from "../type-expressio
 import { isHttpMetadata, isReadOnly } from "@azure-tools/typespec-client-generator-core";
 import { isMetadata } from "@typespec/http";
 import { useContext } from "../../contextManager.js";
+import { isExtensibleEnum } from "../type-expressions/get-enum-expression.js";
 export function getSendPrivateFunction(dpgContext, client, method, clientType) {
     const operation = method[1];
     const parameters = getOperationSignatureParameters(dpgContext, method, clientType);
@@ -61,7 +63,7 @@ export function getSendPrivateFunction(dpgContext, client, method, clientType) {
     };
 }
 export function getDeserializePrivateFunction(context, operation) {
-    var _a, _b, _c, _d, _e, _f;
+    var _a, _b, _c, _d, _e, _f, _g;
     const { name } = getOperationName(operation);
     const dependencies = useDependencies();
     const PathUncheckedResponseReference = resolveReference(dependencies.PathUncheckedResponse);
@@ -71,15 +73,14 @@ export function getDeserializePrivateFunction(context, operation) {
             type: PathUncheckedResponseReference
         }
     ];
-    // TODO: Support LRO + paging operation
-    // https://github.com/Azure/autorest.typescript/issues/2313
     const isLroOnly = isLroOnlyOperation(operation);
+    const isLroAndPaging = isLroAndPagingOperation(operation);
     // TODO: Support operation overloads
     // TODO: Support multiple responses
     const response = operation.response;
     const restResponse = operation.operation.responses[0];
     let returnType;
-    if (isLroOnly) {
+    if (isLroOnly || isLroAndPaging) {
         returnType = buildLroReturnType(context, operation);
     }
     else if (response.type && restResponse) {
@@ -102,7 +103,7 @@ export function getDeserializePrivateFunction(context, operation) {
     const createRestErrorReference = resolveReference(dependencies.createRestError);
     statements.push(`const expectedStatuses = ${getExpectedStatuses(operation)};`);
     statements.push(`if(!expectedStatuses.includes(result.status)){`, `${getExceptionThrowStatement(context, operation)}`, "}");
-    const deserializedType = isLroOnly
+    const deserializedType = isLroOnly || isLroAndPaging
         ? (_c = (_b = operation === null || operation === void 0 ? void 0 : operation.lroMetadata) === null || _b === void 0 ? void 0 : _b.finalResponse) === null || _c === void 0 ? void 0 : _c.result
         : restResponse
             ? restResponse.type
@@ -127,21 +128,86 @@ export function getDeserializePrivateFunction(context, operation) {
       `);
     }
     if (deserializedType) {
-        const contentTypes = (_f = operation.operation.responses[0]) === null || _f === void 0 ? void 0 : _f.contentTypes;
-        const deserializeFunctionName = buildModelDeserializer(context, deserializedType, {
-            nameOnly: true,
-            skipDiscriminatedUnionSuffix: false
-        });
-        if (deserializeFunctionName) {
-            statements.push(`return ${deserializeFunctionName}(${deserializedRoot})`);
+        const contentTypes = (_g = (_f = operation.operation.responses[0]) === null || _f === void 0 ? void 0 : _f.contentTypes) !== null && _g !== void 0 ? _g : [];
+        const isXml = isXmlPayload(contentTypes);
+        const isDualFormat = hasDualFormatSupport(contentTypes);
+        const isMultipart = isMultipartPayload(contentTypes);
+        const useXmlDeserialization = isXml &&
+            deserializedType.kind === "model" &&
+            hasXmlSerialization(deserializedType);
+        // Workaround for multipart response: cast return value as any due to lack of multipart response handling in core
+        const multipartCastSuffix = isMultipart ? " as any" : "";
+        // For dual-format responses, check content-type header at runtime
+        if (isDualFormat &&
+            deserializedType.kind === "model" &&
+            hasXmlSerialization(deserializedType)) {
+            const xmlDeserializerName = buildXmlModelDeserializer(context, deserializedType, {
+                nameOnly: true,
+                skipDiscriminatedUnionSuffix: false
+            });
+            const jsonDeserializerName = buildModelDeserializer(context, deserializedType, {
+                nameOnly: true,
+                skipDiscriminatedUnionSuffix: false
+            });
+            if (xmlDeserializerName && jsonDeserializerName) {
+                const isXmlContentTypeRef = resolveReference(XmlHelpers.isXmlContentType);
+                statements.push(`const responseContentType = result.headers?.["content-type"] ?? "";
+          if (${isXmlContentTypeRef}(responseContentType)) {
+            return ${xmlDeserializerName}(${deserializedRoot});
+          }
+          return ${jsonDeserializerName}(${deserializedRoot});`);
+            }
+            else {
+                // Fall back to JSON deserializer
+                const deserializeFunctionName = buildModelDeserializer(context, deserializedType, {
+                    nameOnly: true,
+                    skipDiscriminatedUnionSuffix: false
+                });
+                if (deserializeFunctionName) {
+                    statements.push(`return ${deserializeFunctionName}(${deserializedRoot})`);
+                }
+            }
         }
-        else if (isAzureCoreErrorType(context.program, deserializedType.__raw)) {
-            statements.push(`return ${deserializedRoot}`);
+        else if (useXmlDeserialization) {
+            // XML-only response
+            const xmlDeserializerName = buildXmlModelDeserializer(context, deserializedType, {
+                nameOnly: true,
+                skipDiscriminatedUnionSuffix: false
+            });
+            if (xmlDeserializerName) {
+                statements.push(`return ${xmlDeserializerName}(${deserializedRoot})`);
+            }
+            else {
+                // Fall back to JSON deserializer if XML deserializer is not available
+                const deserializeFunctionName = buildModelDeserializer(context, deserializedType, {
+                    nameOnly: true,
+                    skipDiscriminatedUnionSuffix: false
+                });
+                if (deserializeFunctionName) {
+                    statements.push(`return ${deserializeFunctionName}(${deserializedRoot})`);
+                }
+                else {
+                    statements.push(`return ${deserializedRoot}`);
+                }
+            }
         }
         else {
-            statements.push(`return ${deserializeResponseValue(context, deserializedType, deserializedRoot, true, isBinaryPayload(context, response.type.__raw, contentTypes)
-                ? "binary"
-                : getEncodeForType(deserializedType))}`);
+            // JSON response (default) - also handles multipart responses
+            const deserializeFunctionName = buildModelDeserializer(context, deserializedType, {
+                nameOnly: true,
+                skipDiscriminatedUnionSuffix: false
+            });
+            if (deserializeFunctionName) {
+                statements.push(`return ${deserializeFunctionName}(${deserializedRoot})${multipartCastSuffix}`);
+            }
+            else if (isAzureCoreErrorType(context.program, deserializedType.__raw)) {
+                statements.push(`return ${deserializedRoot}${multipartCastSuffix}`);
+            }
+            else {
+                statements.push(`return ${deserializeResponseValue(context, deserializedType, deserializedRoot, true, isBinaryPayload(context, response.type.__raw, contentTypes)
+                    ? "binary"
+                    : getEncodeForType(deserializedType))}${multipartCastSuffix}`);
+            }
         }
     }
     else if (returnType.type === "void") {
@@ -292,8 +358,8 @@ export function getOperationFunction(context, method, clientType) {
         return getLroOnlyOperationFunction(context, [method[0], operation], clientType, optionalParamName);
     }
     else if (isLroAndPagingOperation(operation)) {
-        // Case 3: both paging + lro operation is not supported yet so handle them as normal operation and customization may be needed
-        // https://github.com/Azure/autorest.typescript/issues/2313
+        // Case 3: both paging + lro operation
+        return getLroAndPagingOperationFunction(context, [method[0], operation], clientType, optionalParamName);
     }
     // TODO: Support operation overloads
     const response = operation.response;
@@ -390,6 +456,77 @@ function getLroOnlyOperationFunction(context, method, clientType, optionalParamN
         statements
     };
 }
+function getLroAndPagingOperationFunction(context, method, clientType, optionalParamName = "options") {
+    var _a;
+    const operation = method[1];
+    const parameters = getOperationSignatureParameters(context, method, clientType);
+    const { name, fixme = [] } = getOperationName(operation);
+    const returnType = buildLroPagingReturnType(context, operation);
+    // Build paging options from metadata
+    const pagingOptions = [
+        operation.response.resultSegments &&
+            `itemName: "${operation.response.resultSegments.map((p) => p.name).join(".")}"`,
+        operation.pagingMetadata.nextLinkSegments &&
+            `nextLinkName: "${operation.pagingMetadata.nextLinkSegments.map((p) => p.name).join(".")}"`,
+        operation.pagingMetadata.nextLinkVerb !== "GET" &&
+            `nextLinkMethod: "${operation.pagingMetadata.nextLinkVerb}"`
+    ].filter(Boolean);
+    // Build LRO resource location config
+    const allowedLocations = [
+        "azure-async-operation",
+        "location",
+        "original-uri",
+        "operation-location"
+    ];
+    const resourceLocationConfig = ((_a = operation.lroMetadata) === null || _a === void 0 ? void 0 : _a.finalStateVia) &&
+        allowedLocations.includes(operation.lroMetadata.finalStateVia)
+        ? `resourceLocationConfig: "${operation.lroMetadata.finalStateVia}"`
+        : "";
+    // Resolve references
+    const refs = {
+        pagedIterator: resolveReference(PagingHelpers.PagedAsyncIterableIterator),
+        buildPaging: resolveReference(PagingHelpers.BuildPagedAsyncIterator),
+        getLroPoller: resolveReference(PollingHelpers.GetLongRunningPoller),
+        pollerLike: resolveReference(AzurePollingDependencies.PollerLike),
+        operationState: resolveReference(AzurePollingDependencies.OperationState),
+        pathResponse: resolveReference(useDependencies().PathUncheckedResponse)
+    };
+    const expectedStatuses = getExpectedStatuses(operation);
+    const paramList = parameters.map((p) => p.name).join(", ");
+    const pagingOptionsStr = pagingOptions.length > 0 ? `,\n    {${pagingOptions.join(", ")}}` : "";
+    return {
+        kind: StructureKind.Function,
+        docs: [
+            ...getDocsFromDescription(operation.doc),
+            ...getFixmeForMultilineDocs(fixme)
+        ],
+        isAsync: false,
+        isExported: true,
+        name,
+        propertyName: normalizeName(operation.name, NameType.Property),
+        parameters,
+        returnType: `${refs.pagedIterator}<${returnType.type}>`,
+        statements: [
+            `
+  const initialPagingPoller = ${refs.getLroPoller}(context,
+    async (result: ${refs.pathResponse}) => result,
+    ${expectedStatuses}, {
+    updateIntervalInMs: ${optionalParamName}?.updateIntervalInMs,
+    abortSignal: ${optionalParamName}?.abortSignal,
+    getInitialResponse: () => _${name}Send(${paramList}),
+    ${resourceLocationConfig}
+  }) as ${refs.pollerLike}<${refs.operationState}<${refs.pathResponse}>, ${refs.pathResponse}>;
+  
+  return ${refs.buildPaging}(
+    context,
+    async () => await initialPagingPoller,
+    _${name}Deserialize,
+    ${expectedStatuses}${pagingOptionsStr}
+  );
+  `
+        ]
+    };
+}
 function buildLroReturnType(context, operation) {
     const metadata = operation.lroMetadata;
     if (metadata !== undefined && metadata.finalResponse !== undefined) {
@@ -401,6 +538,16 @@ function buildLroReturnType(context, operation) {
     }
     return { name: "", type: "void" };
 }
+function buildLroPagingReturnType(context, operation) {
+    var _a, _b;
+    if (((_a = operation.response.type) === null || _a === void 0 ? void 0 : _a.kind) === "array") {
+        return {
+            name: (_b = operation.response.type.valueType.name) !== null && _b !== void 0 ? _b : "",
+            type: getTypeExpression(context, operation.response.type.valueType)
+        };
+    }
+    return { name: "", type: "void" };
+}
 function getPagingOnlyOperationFunction(context, method, clientType) {
     var _a;
     const operation = method[1];
@@ -552,15 +699,49 @@ function buildBodyParameter(context, bodyParameter, optionalParamName = "options
     if (!bodyParameter || !bodyParameter.type) {
         return "";
     }
-    const serializerFunctionName = buildModelSerializer(context, getNullableValidType(bodyParameter.type), {
-        nameOnly: true,
-        skipDiscriminatedUnionSuffix: false
-    });
+    const contentTypes = bodyParameter.contentTypes;
+    const isXml = isXmlPayload(contentTypes);
+    const isDualFormat = hasDualFormatSupport(contentTypes);
+    const bodyType = getNullableValidType(bodyParameter.type);
+    // Check if XML serialization is needed and available
+    const useXmlSerialization = isXml && bodyType.kind === "model" && hasXmlSerialization(bodyType);
+    let serializerFunctionName;
+    if (useXmlSerialization) {
+        // Use XML serializer
+        serializerFunctionName = buildXmlModelSerializer(context, bodyType, {
+            nameOnly: true,
+            skipDiscriminatedUnionSuffix: false
+        });
+    }
+    else {
+        // Use JSON serializer (default)
+        serializerFunctionName = buildModelSerializer(context, bodyType, {
+            nameOnly: true,
+            skipDiscriminatedUnionSuffix: false
+        });
+    }
     const bodyParamName = normalizeName(bodyParameter.name, NameType.Parameter, true);
     const bodyNameExpression = bodyParameter.optional
         ? `${optionalParamName}["${bodyParamName}"]`
         : bodyParamName;
     const nullOrUndefinedPrefix = getPropertySerializationPrefix(context, bodyParameter, bodyParameter.optional ? optionalParamName : undefined);
+    // For dual-format operations, check the contentType option at runtime
+    if (isDualFormat &&
+        bodyType.kind === "model" &&
+        hasXmlSerialization(bodyType)) {
+        const xmlSerializerName = buildXmlModelSerializer(context, bodyType, {
+            nameOnly: true,
+            skipDiscriminatedUnionSuffix: false
+        });
+        const jsonSerializerName = buildModelSerializer(context, bodyType, {
+            nameOnly: true,
+            skipDiscriminatedUnionSuffix: false
+        });
+        if (xmlSerializerName && jsonSerializerName) {
+            const isXmlContentTypeRef = resolveReference(XmlHelpers.isXmlContentType);
+            return `\nbody: ${nullOrUndefinedPrefix}(${isXmlContentTypeRef}(${optionalParamName}?.contentType ?? "application/json") ? ${xmlSerializerName}(${bodyNameExpression}) : ${jsonSerializerName}(${bodyNameExpression})),`;
+        }
+    }
     // if a model being used in both spread and non spread operation, we should only leverage the deserializer in non spread operation
     if (serializerFunctionName && !isSpreadBodyParameter(bodyParameter)) {
         return `\nbody: ${nullOrUndefinedPrefix}${serializerFunctionName}(${bodyNameExpression}),`;
@@ -585,18 +766,22 @@ function getEncodingFormat(type) {
  * This function helps with renames, translating client names to rest api names
  */
 export function getParameterMap(context, param, optionalParamName = "options") {
+    // Use lowercase for header names since HTTP headers are case-insensitive
+    const serializedName = param.kind === "header"
+        ? getHeaderSerializedName(param)
+        : getPropertySerializedName(param);
     if (isConstant(param.type)) {
-        return `"${param.name}": ${getConstantValue(param.type)}`;
+        return `"${serializedName}": ${getConstantValue(param.type)}`;
     }
     if (hasCollectionFormatInfo(param.kind, param.collectionFormat)) {
-        return getCollectionFormatForParam(context, param, optionalParamName);
+        return getCollectionFormatForParam(context, param, optionalParamName, serializedName);
     }
     // if the parameter or property is optional, we don't need to handle the default value
     if (isOptional(param)) {
-        return getOptional(context, param, optionalParamName);
+        return getOptional(context, param, optionalParamName, serializedName);
     }
     if (isRequired(param)) {
-        return getRequired(context, param);
+        return getRequired(context, param, serializedName);
     }
     reportDiagnostic(context.program, {
         code: "unsupported-parameter-type",
@@ -609,8 +794,7 @@ export function getParameterMap(context, param, optionalParamName = "options") {
     // Return a fallback value to allow the emitter to continue
     return `"${param.name}": undefined`;
 }
-function getCollectionFormatForParam(context, param, optionalParamName = "options") {
-    const serializedName = getPropertySerializedName(param);
+function getCollectionFormatForParam(context, param, optionalParamName = "options", serializedName) {
     const format = param.collectionFormat;
     return `"${serializedName}": ${serializeRequestValue(context, param.type, param.optional ? `${optionalParamName}?.${param.name}` : param.name, !param.optional, format, serializedName, true)}`;
 }
@@ -636,8 +820,7 @@ function getContentTypeValue(param, optionalParamName = "options") {
 function isRequired(param) {
     return !param.optional;
 }
-function getRequired(context, param) {
-    const serializedName = getPropertySerializedName(param);
+function getRequired(context, param, serializedName) {
     const clientValue = `${param.onClient ? "context." : ""}${param.name}`;
     if (param.type.kind === "model") {
         const propertiesStr = getRequestModelMapping(context, { ...param.type, optional: param.optional }, clientValue);
@@ -657,8 +840,7 @@ function isConstant(param) {
 function isOptional(param) {
     return Boolean(param.optional);
 }
-function getOptional(context, param, optionalParamName) {
-    const serializedName = getPropertySerializedName(param);
+function getOptional(context, param, optionalParamName, serializedName) {
     const paramName = `${param.onClient ? "context." : `${optionalParamName}?.`}${param.name}`;
     if (param.type.kind === "model") {
         const propertiesStr = getRequestModelMapping(context, { ...param.type, optional: param.optional }, paramName + "?.");
@@ -770,8 +952,8 @@ function getNullableCheck(name, type) {
  */
 function getEncodeForModelProperty(context, property) {
     if (property.encode && property.type.kind === "array") {
-        // Only arrays of string type can have collectionFormat encoding
-        if (property.type.valueType.kind !== "string") {
+        // Only arrays of string type or string-based enum type can have collectionFormat encoding
+        if (!isStringEncodableArrayValueType(property.type.valueType)) {
             reportDiagnostic(context.program, {
                 code: "un-supported-array-encoding",
                 format: {
@@ -790,6 +972,22 @@ function getEncodeForModelProperty(context, property) {
     }
     return getEncodeForType(property.type);
 }
+/**
+ * Checks if an array value type is string-encodable for collection format encoding.
+ * This includes both string type and string-based enum types.
+ */
+function isStringEncodableArrayValueType(valueType) {
+    // Direct string type
+    if (valueType.kind === "string") {
+        return true;
+    }
+    // String-based enum type
+    if (valueType.kind === "enum" &&
+        valueType.valueType.kind === "string") {
+        return true;
+    }
+    return false;
+}
 function getSerializationExpressionForFlatten(context, property, propertyPath) {
     const serializeFunctionName = buildPropertySerializer(context, property, {
         nameOnly: true,
@@ -867,6 +1065,13 @@ function getPropertySerializedName(property) {
         ? (_a = property.serializationOptions.json) === null || _a === void 0 ? void 0 : _a.name
         : property.serializedName)) !== null && _b !== void 0 ? _b : property.name);
 }
+/**
+ * Get the serialized name for a header parameter, normalized to lowercase.
+ * HTTP headers are case-insensitive, so we normalize to lowercase for consistency.
+ */
+function getHeaderSerializedName(param) {
+    return getPropertySerializedName(param).toLowerCase();
+}
 /**
  * This function helps translating an RLC response to an HLC response,
  * extracting properties from body and headers and building the HLC response object
@@ -1053,7 +1258,14 @@ export function deserializeResponseValue(context, type, restValue, required, for
                         const optionalPrefixForString = isTypeNullable(type) || getOptionalForType(type) || !required
                             ? `${restValue} === null || ${restValue} === undefined ? ${restValue}: `
                             : "";
-                        return `${optionalPrefixForString}${parseHelper}(${restValue})`;
+                        if (type.valueType.kind === "enum" &&
+                            !isExtensibleEnum(context, type.valueType)) {
+                            // Special handling for non-extensible enums to cast the result to the correct type
+                            return `${optionalPrefixForString}${parseHelper}(${restValue}) as ${getTypeExpression(context, type)}`;
+                        }
+                        else {
+                            return `${optionalPrefixForString}${parseHelper}(${restValue})`;
+                        }
                     }
                 }
                 return `${prefix}.map((${varName}: any) => { return ${elementNullOrUndefinedPrefix}${deserializeResponseValue(context, type.valueType, varName, true, getEncodeForType(type.valueType), recursionDepth + 1)}})`;
@@ -1172,9 +1384,11 @@ export function getPropertySerializationPrefix(context, property, propertyPath)
     return "";
 }
 export function getPropertyFullName(context, property, propertyPath) {
-    const normalizedPropertyName = normalizeModelPropertyName(context, property)
-        .replace(/^"/g, "")
-        .replace(/"$/g, "");
+    const normalizedPropertyName = propertyPath === ""
+        ? normalizeName(property.name, NameType.Parameter, true)
+        : normalizeModelPropertyName(context, property)
+            .replace(/^"/g, "")
+            .replace(/"$/g, "");
     let fullName = normalizedPropertyName;
     if (propertyPath === "" && property.optional) {
         fullName = `options?.${normalizedPropertyName}`;
@@ -1191,8 +1405,17 @@ export function getPropertyFullName(context, property, propertyPath) {
 export function getExpectedStatuses(operation) {
     let statusCodes = operation.operation.responses.map((x) => x.statusCodes);
     // LROs may call the same path but with GET to get the operation status.
-    if (isLroOnlyOperation(operation) && operation.operation.verb !== "get") {
-        statusCodes = Array.from(new Set([...statusCodes, 200, 201, 202]));
+    if ((isLroOnlyOperation(operation) || isLroAndPagingOperation(operation)) &&
+        operation.operation.verb !== "get") {
+        // DELETE: Add 200, 202 for polling
+        // POST/PUT/PATCH: Add 200, 201, 202 for polling
+        const verb = operation.operation.verb.toLowerCase();
+        if (verb === "delete") {
+            statusCodes = Array.from(new Set([...statusCodes, 200, 202]));
+        }
+        else {
+            statusCodes = Array.from(new Set([...statusCodes, 200, 201, 202]));
+        }
     }
     return `[${statusCodes.map((x) => `"${x}"`).join(", ")}]`;
 }