@azure-tools/typespec-ts 0.51.1 → 0.52.0

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

@@ -22,6 +22,7 @@ import { getClientOptions, isHttpMetadata, isReadOnly } from "@azure-tools/types
 import { isHeader, isMetadata } from "@typespec/http";
 import { useContext } from "../../contextManager.js";
 import { getHeaderClientOptions, getRestErrorCodeHeader } from "./clientOptionHelpers.js";
+import { getClientParameterName } from "./clientHelpers.js";
 import { isExtensibleEnum } from "../type-expressions/get-enum-expression.js";
 import { emitInlineModel } from "../type-expressions/get-model-expression.js";
 /**
@@ -96,7 +97,16 @@ export function getDeserializePrivateFunction(context, method) {
     const restResponse = operation.operation.responses[0];
     let returnType;
     if (isLroOnly || isLroAndPaging) {
-        returnType = buildLroReturnType(context, operation);
+        if (isLroOnly && shouldWrap) {
+            // For LRO-only operations with non-model final result, wrap in a response type alias
+            returnType = {
+                name: getOperationResponseTypeName(method),
+                type: resolveReference(refkey(operation, "response"))
+            };
+        }
+        else {
+            returnType = buildLroReturnType(context, operation);
+        }
     }
     else if (isPagingOnly && (restResponse === null || restResponse === void 0 ? void 0 : restResponse.type)) {
         // For paging operations, use the full response model (e.g., _OperationListResult)
@@ -237,7 +247,7 @@ export function getDeserializePrivateFunction(context, method) {
                 nameOnly: true,
                 skipDiscriminatedUnionSuffix: false
             });
-            // Handle wrap-non-model-return for non-LRO, non-paging operations
+            // Handle wrap-non-model-return for non-LRO, non-paging and LRO-only operations
             if (shouldWrap) {
                 if (isBinary) {
                     // Binary wrap: getBinaryStream already resolved the stream,
@@ -247,8 +257,9 @@ export function getDeserializePrivateFunction(context, method) {
                 }
                 else {
                     // Non-model response: wrap with body property
-                    // Generate the appropriate deserialization for the body value
-                    const bodyValue = deserializeResponseValue(context, deserializedType, "result.body", true, getEncodeForType(deserializedType));
+                    // Generate the appropriate deserialization for the body value.
+                    // For LRO operations, deserializedRoot may include the sub-path (e.g. result.body.someProperty).
+                    const bodyValue = deserializeResponseValue(context, deserializedType, deserializedRoot, true, getEncodeForType(deserializedType));
                     statements.push(`return { body: ${bodyValue} };`);
                 }
                 return {
@@ -829,6 +840,15 @@ function getLroOnlyOperationFunction(context, method, clientType, optionalParamN
     const { name, fixme = [] } = getOperationName(operation);
     const pollerLikeReference = resolveReference(AzurePollingDependencies.PollerLike);
     const operationStateReference = resolveReference(AzurePollingDependencies.OperationState);
+    // When wrap-non-model-return is enabled and the LRO final result is a non-model type,
+    // use the wrapper response type (e.g. GetIkeSasResponse) instead of the raw type (e.g. string).
+    const { shouldWrap } = checkWrapNonModelReturn(context, operation);
+    const effectiveReturnTypeStr = shouldWrap
+        ? resolveReference(refkey(operation, "response"))
+        : returnType.type;
+    const effectiveReturnTypeName = shouldWrap
+        ? getOperationResponseTypeName(method)
+        : returnType.type;
     const functionStatement = {
         kind: StructureKind.Function,
         docs: [
@@ -840,9 +860,9 @@ function getLroOnlyOperationFunction(context, method, clientType, optionalParamN
         name,
         propertyName: normalizeName(operation.name, NameType.Property),
         isLro: true,
-        lroFinalReturnType: returnType.type,
+        lroFinalReturnType: effectiveReturnTypeName,
         parameters,
-        returnType: `${pollerLikeReference}<${operationStateReference}<${returnType.type}>, ${returnType.type}>`
+        returnType: `${pollerLikeReference}<${operationStateReference}<${effectiveReturnTypeStr}>, ${effectiveReturnTypeStr}>`
     };
     const getLongRunningPollerReference = resolveReference(PollingHelpers.GetLongRunningPoller);
     const lroMetadata = operation.kind === "lro" || operation.kind === "lropaging"
@@ -870,7 +890,7 @@ function getLroOnlyOperationFunction(context, method, clientType, optionalParamN
         .join(", ")}),
     ${resourceLocationConfig}
     ${apiVersion ? `apiVersion: ${apiVersion}` : ""}
-  }) as ${pollerLikeReference}<${operationStateReference}<${returnType.type}>, ${returnType.type}>;
+  }) as ${pollerLikeReference}<${operationStateReference}<${effectiveReturnTypeStr}>, ${effectiveReturnTypeStr}>;
   `);
     return {
         ...functionStatement,
@@ -1082,9 +1102,11 @@ function getHeaderAndBodyParameters(dpgContext, operation, optionalParamName = "
             // Check if this parameter still exists in the corresponding method params (after override)
             if (param.methodParameterSegments &&
                 param.methodParameterSegments.length > 0) {
+                const paramAccessor = getParamAccessor(param, optionalParamName);
                 parametersImplementation[param.kind].push({
-                    paramMap: getParameterMap(dpgContext, param, optionalParamName),
-                    param
+                    paramMap: getParameterMap(dpgContext, param, paramAccessor),
+                    param,
+                    paramAccessor
                 });
             }
         }
@@ -1095,7 +1117,7 @@ function getHeaderAndBodyParameters(dpgContext, operation, optionalParamName = "
     }
     if (parametersImplementation.header.length) {
         paramStr = `${paramStr}\nheaders: {${parametersImplementation.header
-            .map((i) => buildHeaderParameter(dpgContext.program, i.paramMap, i.param, optionalParamName))
+            .map((i) => buildHeaderParameter(dpgContext.program, i.paramMap, i.param, i.paramAccessor))
             .join(",\n")}, ...${optionalParamName}.requestOptions?.headers },`;
     }
     if (operation.operation.bodyParam === undefined &&
@@ -1110,8 +1132,7 @@ function getHeaderAndBodyParameters(dpgContext, operation, optionalParamName = "
     return paramStr;
 }
 // Specially handle the type for headers because we only allow string/number/boolean values
-function buildHeaderParameter(program, paramMap, param, optionalParamName = "options") {
-    const paramName = param.name;
+function buildHeaderParameter(program, paramMap, param, paramAccessor) {
     const effectiveOptional = getEffectiveOptional(param);
     if (!effectiveOptional && isTypeNullable(param.type) === true) {
         reportDiagnostic(program, {
@@ -1122,10 +1143,10 @@ function buildHeaderParameter(program, paramMap, param, optionalParamName = "opt
     }
     const conditions = [];
     if (effectiveOptional) {
-        conditions.push(`${optionalParamName}?.${paramName} !== undefined`);
+        conditions.push(`${paramAccessor} !== undefined`);
     }
     if (isTypeNullable(param.type) === true) {
-        conditions.push(`${optionalParamName}?.${paramName} !== null`);
+        conditions.push(`${paramAccessor} !== null`);
     }
     return conditions.length > 0
         ? `...(${conditions.join(" && ")} ? {${paramMap}} : {})`
@@ -1214,7 +1235,7 @@ function getEncodingFormat(type) {
 /**
  * This function helps with renames, translating client names to rest api names
  */
-export function getParameterMap(context, param, optionalParamName = "options") {
+export function getParameterMap(context, param, paramAccessor) {
     var _a;
     // Use lowercase for header names since HTTP headers are case-insensitive
     const serializedName = param.kind === "header"
@@ -1232,14 +1253,14 @@ export function getParameterMap(context, param, optionalParamName = "options") {
         return `"${serializedName}": ${param.onClient ? "context." : ""}${param.name} ?? "${param.clientDefaultValue}"`;
     }
     if (hasCollectionFormatInfo(param.kind, param.collectionFormat)) {
-        return getCollectionFormatForParam(context, param, optionalParamName, serializedName);
+        return getCollectionFormatForParam(context, param, paramAccessor, 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, serializedName);
+        return getOptional(context, param, serializedName, paramAccessor);
     }
     if (isRequired(param)) {
-        return getRequired(context, param, serializedName);
+        return getRequired(context, param, serializedName, paramAccessor);
     }
     reportDiagnostic(context.program, {
         code: "unsupported-parameter-type",
@@ -1252,9 +1273,9 @@ 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", serializedName) {
+function getCollectionFormatForParam(context, param, paramAccessor, serializedName) {
     const format = param.collectionFormat;
-    return `"${serializedName}": ${serializeRequestValue(context, param.type, param.optional ? `${optionalParamName}?.${param.name}` : param.name, !param.optional, format, serializedName, true)}`;
+    return `"${serializedName}": ${serializeRequestValue(context, param.type, paramAccessor, !param.optional, format, serializedName, true)}`;
 }
 function isContentType(param) {
     return (param.kind === "header" &&
@@ -1302,13 +1323,12 @@ function getEffectiveOptional(param) {
 function isRequired(param) {
     return !getEffectiveOptional(param);
 }
-function getRequired(context, param, serializedName) {
-    const clientValue = `${param.onClient ? "context." : ""}${param.name}`;
+function getRequired(context, param, serializedName, paramAccessor) {
     if (param.type.kind === "model") {
-        const propertiesStr = getRequestModelMapping(context, { ...param.type, optional: param.optional }, clientValue);
+        const propertiesStr = getRequestModelMapping(context, { ...param.type, optional: param.optional }, paramAccessor);
         return `"${serializedName}": { ${propertiesStr.join(",")} }`;
     }
-    return `"${serializedName}": ${serializeRequestValue(context, param.type, clientValue, true, getEncodeForType(param.type), serializedName, true)}`;
+    return `"${serializedName}": ${serializeRequestValue(context, param.type, paramAccessor, true, getEncodeForType(param.type), serializedName, true)}`;
 }
 function getConstantValue(param) {
     if (typeof param.value === "string") {
@@ -1322,19 +1342,18 @@ function isConstant(param) {
 function isOptional(param) {
     return getEffectiveOptional(param);
 }
-function getOptional(context, param, optionalParamName, serializedName) {
-    const paramName = `${param.onClient ? "context." : `${optionalParamName}?.`}${param.name}`;
+function getOptional(context, param, serializedName, paramAccessor) {
     // Apply client default value if present and type matches
     const defaultSuffix = param.clientDefaultValue !== undefined &&
         isDefaultValueTypeMatch(param, param.clientDefaultValue)
         ? ` ?? ${formatDefaultValue(param.clientDefaultValue)}`
         : "";
     if (param.type.kind === "model") {
-        const propertiesStr = getRequestModelMapping(context, { ...param.type, optional: param.optional }, paramName + "?.");
+        const propertiesStr = getRequestModelMapping(context, { ...param.type, optional: param.optional }, paramAccessor + "?.");
         const serializeContent = `{${propertiesStr.join(",")}}`;
         return `"${serializedName}": ${serializeContent}`;
     }
-    const serializedValue = serializeRequestValue(context, param.type, paramName, false, getEncodeForType(param.type), serializedName, true);
+    const serializedValue = serializeRequestValue(context, param.type, paramAccessor, false, getEncodeForType(param.type), serializedName, true);
     return `"${serializedName}": ${serializedValue}${defaultSuffix}`;
 }
 /**
@@ -1368,7 +1387,7 @@ function getPathParameters(operation, optionalParamName = "options") {
         if (param.kind === "path") {
             const methodParam = (_a = param.methodParameterSegments[0]) === null || _a === void 0 ? void 0 : _a[0];
             if (methodParam) {
-                pathParams.push(`"${param.serializedName}": ${getPathParamExpr(methodParam, getDefaultValue(param), optionalParamName)}`);
+                pathParams.push(`"${param.serializedName}": ${getPathParamExpr(param, getDefaultValue(param), optionalParamName)}`);
             }
         }
     }
@@ -1390,13 +1409,14 @@ function getQueryParameters(dpgContext, operation) {
             // Check if this parameter still exists in the corresponding method params (after override)
             if (param.methodParameterSegments &&
                 param.methodParameterSegments.length > 0) {
+                const paramAccessor = getParamAccessor(param);
                 parametersImplementation[param.kind].push({
                     paramMap: getParameterMap(dpgContext, {
                         ...param,
                         // TODO: remember to remove this hack once compiler gives us a name
                         // https://github.com/microsoft/typespec/issues/6743
                         serializedName: getUriTemplateQueryParamName(param.serializedName)
-                    }),
+                    }, paramAccessor),
                     param
                 });
             }
@@ -1413,15 +1433,69 @@ function escapeUriTemplateParamName(name) {
         return "%" + c.charCodeAt(0).toString(16).toUpperCase();
     });
 }
+/**
+ * Returns the parameter expression matching the operation signature for an HTTP parameter.
+ * 1. Client-level parameter (`param.onClient`): returns `context.<paramName>`.
+ * 2. Method-level parameter with `methodParameterSegments`: returns the expression
+ *    built from those segments (e.g. `options?.ocpDate`, `body.nested`).
+ * 3. Fallback: returns the parameter name directly, with optional chaining if optional.
+ */
+function getParamAccessor(param, optionalParamName = "options") {
+    const methodParamExpr = getMethodParamExpr(param, optionalParamName);
+    const clientPrefix = "context.";
+    if (methodParamExpr) {
+        return param.onClient
+            ? `${clientPrefix}${methodParamExpr}`
+            : methodParamExpr;
+    }
+    if (param.onClient) {
+        return `${clientPrefix}${getClientParameterName(param)}`;
+    }
+    if (getEffectiveOptional(param)) {
+        return `${optionalParamName}?.${param.name}`;
+    }
+    return param.name;
+}
+/**
+ * Builds a property accessor expression from the param's `methodParameterSegments`.
+ * Each segment represents a level of property access (e.g. `options?.nested.value`).
+ * Returns `undefined` when no segments are available, so the caller can fall back.
+ */
+function getMethodParamExpr(param, optionalParamName = "options") {
+    const segments = param.methodParameterSegments;
+    if (segments.length === 0) {
+        return undefined;
+    }
+    const path = segments[0];
+    if (!path || path.length < 1) {
+        return undefined;
+    }
+    const parts = [];
+    for (let i = 0; i < path.length; i++) {
+        const segment = path[i];
+        if (i === 0) {
+            // Normalize names for client-level segments to match the context interface property names
+            const segmentName = segment.onClient
+                ? getClientParameterName(segment)
+                : segment.name;
+            if (segment.optional && !segment.onClient) {
+                // If the first segment is optional and not on the client, we need to start with the optionalParamName
+                parts.push(`${optionalParamName}?.`);
+            }
+            parts.push(segmentName);
+        }
+        else {
+            const needsOptionalChain = path[i - 1].optional;
+            parts.push(`${needsOptionalChain ? "?." : "."}${segment.name}`);
+        }
+    }
+    return parts.join("");
+}
 function getPathParamExpr(param, defaultValue, optionalParamName = "options") {
     if (isConstant(param.type)) {
         return getConstantValue(param.type);
     }
-    const paramName = param.onClient
-        ? `context.${param.name}`
-        : param.optional
-            ? `${optionalParamName}["${param.name}"]`
-            : param.name;
+    const paramName = getParamAccessor(param, optionalParamName);
     return defaultValue
         ? typeof defaultValue === "string"
             ? `${paramName} ?? "${defaultValue}"`
@@ -2132,67 +2206,71 @@ export function getOperationResponseTypeName(method) {
         : "";
     return `${prefix}${normalizeName(operation.name, NameType.Interface)}Response`;
 }
+/**
+ * Returns true when a type should be wrapped with a `body` property.
+ * Wrapping is needed for primitive/enum types; composite (model, dict, model-array)
+ * and unknown-as-record types map to the HLC PropertyKind.Composite / Dictionary
+ * patterns which do NOT get a body wrapper.
+ *
+ * Covered cases (no wrap):
+ *   - model array  (e.g. Foo[])          → HLC PropertyKind.Composite
+ *   - model                               → HLC PropertyKind.Composite
+ *   - dict / Record<string, unknown>      → HLC PropertyKind.Dictionary
+ *   - unknown with treatUnknownAsRecord   → treated as Dict
+ *
+ * Covered cases (wrap):
+ *   - string, boolean, number             → HLC PropertyKind.Primitive
+ *   - string[]                            → HLC PropertyKind.Primitive (item kind)
+ *   - enum / KnownXxx | string            → HLC PropertyKind.Enum
+ *   - any / unknown (no treatAsRecord)    → HLC PropertyKind.Primitive
+ */
+function isWrappableType(context, type) {
+    var _a;
+    if (type.kind === "array" && type.valueType.kind === "model")
+        return false;
+    if (type.kind === "dict" || type.kind === "model")
+        return false;
+    if (type.kind === "unknown" && ((_a = context.rlcOptions) === null || _a === void 0 ? void 0 : _a.treatUnknownAsRecord))
+        return false;
+    return true;
+}
 /**
  * Determines whether wrapping the non-model return type is needed for an operation.
  * Returns an object with `shouldWrap` (whether to wrap) and `isBinary` (whether it's a binary response).
  */
 export function checkWrapNonModelReturn(context, operation) {
-    var _a, _b, _c, _d;
+    var _a, _b, _c, _d, _e;
     const noWrap = { shouldWrap: false, isBinary: false };
-    // Only for non-LRO, non-paging normal operations
-    if (isLroOnlyOperation(operation) ||
-        isLroAndPagingOperation(operation) ||
-        isPagingOnlyOperation(operation)) {
+    // LRO+paging and paging-only operations are not wrapped
+    if (isLroAndPagingOperation(operation) || isPagingOnlyOperation(operation)) {
         return noWrap;
     }
     // Only if the feature flag is enabled
     if (!((_a = context.rlcOptions) === null || _a === void 0 ? void 0 : _a.wrapNonModelReturn)) {
         return noWrap;
     }
-    const response = operation.response;
-    if (!response.type) {
+    // For LRO-only operations, check the final result type from LRO metadata
+    if (isLroOnlyOperation(operation)) {
+        const lroResultType = (_c = (_b = operation.lroMetadata) === null || _b === void 0 ? void 0 : _b.finalResponse) === null || _c === void 0 ? void 0 : _c.result;
+        if (!lroResultType) {
+            return noWrap; // void LRO - no wrap needed
+        }
+        return {
+            shouldWrap: isWrappableType(context, lroResultType),
+            isBinary: false
+        };
+    }
+    const { type } = operation.response;
+    if (!type) {
         return noWrap; // void return type - no wrap needed
     }
-    const type = response.type;
-    const contentTypes = (_c = (_b = operation.operation.responses[0]) === null || _b === void 0 ? void 0 : _b.contentTypes) !== null && _c !== void 0 ? _c : [];
-    // Determine whether to wrap based on the HLC PropertyKind mapping.
-    // HLC wraps with `body` only when the type is PropertyKind.Primitive or PropertyKind.Enum
-    // (i.e. NOT PropertyKind.Composite or PropertyKind.Dictionary).
-    // For array types, HLC uses the item's kind, not the array itself.
-    //
-    // Case: bytes with binary content type → binary wrap (isBinary=true)
+    const contentTypes = (_e = (_d = operation.operation.responses[0]) === null || _d === void 0 ? void 0 : _d.contentTypes) !== null && _e !== void 0 ? _e : [];
+    // bytes with binary content type → binary wrap (isBinary=true)
     //   HLC: bytes → binary payload → separate binary handling
     if (type.__raw && isBinaryPayload(context, type.__raw, contentTypes)) {
         return { shouldWrap: true, isBinary: true };
     }
-    // Case: model array (e.g. Foo[]) → no wrap
-    //   HLC: model array → PropertyKind.Composite (item kind = model) → no body wrapper
-    //   Modular: array with valueType.kind === "model"
-    if (type.kind === "array" && type.valueType.kind === "model") {
-        return noWrap;
-    }
-    // Case: any object / Record (e.g. Record<string, unknown>) → no wrap
-    //   HLC: SchemaType.AnyObject → PropertyKind.Dictionary → no body wrapper
-    //   Modular: kind === "dict"
-    // Case: model → no wrap
-    //   HLC: model → PropertyKind.Composite → no body wrapper
-    //   Modular: kind === "model"
-    if (type.kind === "dict" || type.kind === "model") {
-        return noWrap;
-    }
-    // Case: unknown with treatUnknownAsRecord enabled → no wrap
-    //   When treatUnknownAsRecord is enabled, `unknown` is treated as Record<string, unknown>
-    //   which maps to HLC PropertyKind.Dictionary → no body wrapper
-    if (type.kind === "unknown" && ((_d = context.rlcOptions) === null || _d === void 0 ? void 0 : _d.treatUnknownAsRecord)) {
-        return noWrap;
-    }
-    // Remaining cases → wrap with `body`:
-    //   - string   → HLC PropertyKind.Primitive → modular `string`
-    //   - boolean  → HLC PropertyKind.Primitive → modular `boolean`
-    //   - string[] → HLC PropertyKind.Primitive (array keeps item kind) → modular `string[]`
-    //   - any      → HLC PropertyKind.Primitive → modular `unknown` or `any`
-    //   - enum     → HLC PropertyKind.Enum → modular `KnownXxx | string`
-    return { shouldWrap: true, isBinary: false };
+    return { shouldWrap: isWrappableType(context, type), isBinary: false };
 }
 /**
  * Builds a TypeAliasDeclarationStructure for the non-model response wrapper type.