@azure-tools/typespec-ts 0.34.0 → 0.35.0-alpha.20241203.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@azure-tools/typespec-ts",
-  "version": "0.34.0",
+  "version": "0.35.0-alpha.20241203.1",
   "description": "An experimental TypeSpec emitter for TypeScript RLC",
   "main": "dist/src/index.js",
   "type": "module",
@@ -18,14 +18,14 @@
   "license": "MIT",
   "devDependencies": {
     "@azure-rest/core-client": "^2.3.1",
-    "@azure-tools/cadl-ranch-expect": "^0.15.5",
-    "@azure-tools/cadl-ranch-specs": "^0.38.0",
-    "@azure-tools/cadl-ranch": "^0.15.0",
+    "@azure-tools/cadl-ranch-expect": "^0.15.6",
+    "@azure-tools/cadl-ranch-specs": "^0.39.2",
+    "@azure-tools/cadl-ranch": "^0.16.1",
     "@azure-tools/cadl-ranch-api": "^0.5.0",
-    "@azure-tools/typespec-autorest": ">=0.47.0 <1.0.0",
-    "@azure-tools/typespec-azure-core": ">=0.47.0 <1.0.0",
-    "@azure-tools/typespec-azure-resource-manager": ">=0.47.0 <1.0.0",
-    "@azure-tools/typespec-client-generator-core": ">=0.47.4 <1.0.0",
+    "@azure-tools/typespec-autorest": ">=0.48.0 <1.0.0",
+    "@azure-tools/typespec-azure-core": ">=0.48.0 <1.0.0",
+    "@azure-tools/typespec-azure-resource-manager": ">=0.48.0 <1.0.0",
+    "@azure-tools/typespec-client-generator-core": ">=0.48.0 <1.0.0",
     "@azure/abort-controller": "^2.1.2",
     "@azure/core-auth": "^1.6.0",
     "@azure/core-lro": "^3.1.0",
@@ -40,12 +40,12 @@
     "@types/node": "^18.0.0",
     "@typescript-eslint/eslint-plugin": "^6.8.0",
     "@typescript-eslint/parser": "^6.8.0",
-    "@typespec/compiler": ">=0.61.2 <1.0.0",
-    "@typespec/http": ">=0.61.0 <1.0.0",
-    "@typespec/openapi": ">=0.61.0, <1.0.0",
-    "@typespec/rest": ">=0.61.0 <1.0.0",
+    "@typespec/compiler": ">=0.62.0 <1.0.0",
+    "@typespec/http": ">=0.62.0 <1.0.0",
+    "@typespec/openapi": ">=0.62.0, <1.0.0",
+    "@typespec/rest": ">=0.62.0 <1.0.0",
     "@typespec/ts-http-runtime": "1.0.0-alpha.20240314.2",
-    "@typespec/versioning": ">=0.61.0 <1.0.0",
+    "@typespec/versioning": ">=0.62.0 <1.0.0",
     "chai": "^4.3.6",
     "chalk": "^4.0.0",
     "cross-env": "^7.0.3",
@@ -65,15 +65,15 @@
     "tsx": "^4.16.5"
   },
   "peerDependencies": {
-    "@azure-tools/typespec-azure-core": ">=0.47.0 <1.0.0",
-    "@azure-tools/typespec-client-generator-core": ">=0.47.4 <1.0.0",
-    "@typespec/compiler": ">=0.61.2 <1.0.0",
-    "@typespec/http": ">=0.61.0 <1.0.0",
-    "@typespec/rest": ">=0.61.0 <1.0.0",
-    "@typespec/versioning": ">=0.61.0 <1.0.0"
+    "@azure-tools/typespec-azure-core": ">=0.48.0 <1.0.0",
+    "@azure-tools/typespec-client-generator-core": ">=0.48.0 <1.0.0",
+    "@typespec/compiler": ">=0.62.0 <1.0.0",
+    "@typespec/http": ">=0.62.0 <1.0.0",
+    "@typespec/rest": ">=0.62.0 <1.0.0",
+    "@typespec/versioning": ">=0.62.0 <1.0.0"
   },
   "dependencies": {
-    "@azure-tools/rlc-common": "^0.34.0",
+    "@azure-tools/rlc-common": "^0.35.0",
     "fs-extra": "^11.1.0",
     "lodash": "^4.17.21",
     "prettier": "^3.3.3",

package/src/index.ts

@@ -91,10 +91,9 @@ export async function $onEmit(context: EmitContext) {
   const program: Program = context.program;
   const emitterOptions: EmitterOptions = context.options;
   const dpgContext = await createContextWithDefaultOptions(context);
-  const rlcOptions: RLCOptions = transformRLCOptions(
-    emitterOptions,
-    dpgContext
-  );
+  // Enrich the dpg context with path detail and common options
+  await enrichDpgContext();
+  const rlcOptions = dpgContext.rlcOptions ?? {};
 
   const needUnexpectedHelper: Map<string, boolean> = new Map<string, boolean>();
   const serviceNameToRlcModelsMap: Map<string, RLCModel> = new Map<
@@ -109,7 +108,6 @@ export async function $onEmit(context: EmitContext) {
     compilerContext: context,
     tcgcContext: dpgContext
   });
-  const { modularSourcesDir } = await calculateGenerationDir(rlcOptions);
   const staticHelpers = await loadStaticHelpers(
     outputProject,
     {
@@ -117,7 +115,7 @@ export async function $onEmit(context: EmitContext) {
       ...PagingHelpers,
       ...PollingHelpers
     },
-    { sourcesDir: modularSourcesDir }
+    { sourcesDir: dpgContext.generationPathDetail?.modularSourcesDir }
   );
   const extraDependencies = isAzurePackage({ options: rlcOptions })
     ? {
@@ -136,11 +134,10 @@ export async function $onEmit(context: EmitContext) {
 
   const rlcCodeModels: RLCModel[] = [];
   let modularCodeModel: ModularCodeModel;
-  // 1. Enrich the dpg context with path detail and common options
-  await enrichDpgContext();
-  // 2. Clear sources folder
+
+  // 1. Clear sources folder
   await clearSrcFolder();
-  // 3. Generate RLC code model
+  // 2. Generate RLC code model
   // TODO: skip this step in modular once modular generator is sufficiently decoupled
   await buildRLCCodeModels();
 
@@ -155,28 +152,26 @@ export async function $onEmit(context: EmitContext) {
   await generateMetadataAndTest();
 
   async function enrichDpgContext() {
-    const options: RLCOptions = transformRLCOptions(emitterOptions, dpgContext);
     const generationPathDetail: GenerationDirDetail =
-      await calculateGenerationDir(options);
+      await calculateGenerationDir();
     dpgContext.generationPathDetail = generationPathDetail;
+    const options: RLCOptions = transformRLCOptions(emitterOptions, dpgContext);
+    // clear output folder if needed
+    if (options.clearOutputFolder) {
+      await fsextra.emptyDir(context.emitterOutputDir);
+    }
     const hasTestFolder = await fsextra.pathExists(
       join(dpgContext.generationPathDetail?.metadataDir ?? "", "test")
     );
-    rlcOptions.generateTest =
-      rlcOptions.generateTest === true ||
-      (rlcOptions.generateTest === undefined &&
+    options.generateTest =
+      options.generateTest === true ||
+      (options.generateTest === undefined &&
         !hasTestFolder &&
-        isAzurePackage({ options: rlcOptions }));
-    dpgContext.rlcOptions = rlcOptions;
+        isAzurePackage({ options: options }));
+    dpgContext.rlcOptions = options;
   }
 
-  async function calculateGenerationDir(
-    options: RLCOptions
-  ): Promise<GenerationDirDetail> {
-    // clear output folder if needed
-    if (options.clearOutputFolder) {
-      await fsextra.emptyDir(context.emitterOutputDir);
-    }
+  async function calculateGenerationDir(): Promise<GenerationDirDetail> {
     const projectRoot = context.emitterOutputDir ?? "";
     const customizationFolder = join(projectRoot, "generated");
     // if customization folder exists, use it as sources root
@@ -304,6 +299,9 @@ export async function $onEmit(context: EmitContext) {
     }
 
     binder.resolveAllReferences(modularSourcesRoot);
+    if (program.compilerOptions.noEmit || program.hasError()) {
+      return;
+    }
 
     for (const file of project.getSourceFiles()) {
       file.fixMissingImports(

package/src/lib.ts

@@ -92,7 +92,8 @@ export const RLCOptionsSchema: JSONSchemaType<EmitterOptions> = {
     compatibilityMode: { type: "boolean", nullable: true },
     experimentalExtensibleEnums: { type: "boolean", nullable: true },
     clearOutputFolder: { type: "boolean", nullable: true },
-    ignorePropertyNameNormalize: { type: "boolean", nullable: true }
+    ignorePropertyNameNormalize: { type: "boolean", nullable: true },
+    compatibilityQueryMultiFormat: { type: "boolean", nullable: true }
   },
   required: []
 };
@@ -267,6 +268,18 @@ const libDef = {
       messages: {
         default: paramMessage`Path parameter '${"paramName"}' cannot be optional.`
       }
+    },
+    "un-supported-format-cases": {
+      severity: "warning",
+      messages: {
+        default: paramMessage`The parameter ${"paramName"} with explode: ${"explode"} and format: ${"format"} is not supported.`
+      }
+    },
+    "parameter-type-not-supported": {
+      severity: "warning",
+      messages: {
+        default: paramMessage`Parameter '${"paramName"}' with type '${"paramType"}' is not supported and we would ignore this parameter.`
+      }
     }
   },
   emitter: {

package/src/modular/buildClassicalClient.ts

@@ -108,9 +108,9 @@ export function buildClassicalClient(
     });
 
   constructor.addStatements([
-    `this._client = create${modularClientName}(${paramNames.join(",")})`
+    `this._client = create${modularClientName}(${paramNames.join(",")});`
   ]);
-  constructor.addStatements(`this.pipeline = this._client.pipeline`);
+  constructor.addStatements(`this.pipeline = this._client.pipeline;`);
 
   buildClientOperationGroups(clientFile, _client, dpgContext, clientClass);
   importAllApis(clientFile, srcPath, subfolder);

package/src/modular/buildCodeModel.ts

@@ -509,7 +509,19 @@ function emitParameter(
   context: SdkContext,
   parameter: HttpOperationParameter | HttpServerParameter,
   implementation: string
-): Parameter {
+): Parameter | undefined {
+  if (parameter.type === "cookie") {
+    // TODO: support cookie parameters, https://github.com/Azure/autorest.typescript/issues/2898
+    reportDiagnostic(context.program, {
+      code: "parameter-type-not-supported",
+      format: {
+        paramType: parameter.type,
+        paramName: parameter.name
+      },
+      target: NoTarget
+    });
+    return undefined;
+  }
   const base = emitParamBase(context, parameter.param);
   let type = getType(context, parameter.param.type, {
     usage: UsageFlags.Input
@@ -857,6 +869,9 @@ function emitBasicOperation(
       continue;
     }
     const emittedParam = emitParameter(context, param, "Method");
+    if (emittedParam === undefined) {
+      continue;
+    }
     if (isApiVersion(context, param)) {
       emittedParam.isApiVersion = true;
       methodApiVersionParam = emittedParam;
@@ -1719,6 +1734,9 @@ function emitServerParams(
         serverParameter,
         "Client"
       );
+      if (emittedParameter === undefined) {
+        continue;
+      }
       endpointPathParameters.push(emittedParameter);
       if (isApiVersion(context, serverParameter as any)) {
         emittedParameter.isApiVersion = true;

package/src/modular/helpers/clientHelpers.ts

@@ -228,7 +228,7 @@ export function buildGetClientOptionsParam(
     expr += `credentials: ${credentials},`;
   }
 
-  expr += `}`;
+  expr += `};`;
 
   context.addStatements(expr);
   return "updatedOptions";

package/src/modular/helpers/operationHelpers.ts

@@ -997,7 +997,7 @@ export function serializeRequestValue(
         case "headerDefault":
           return `${nullOrUndefinedPrefix}${clientValue}.toUTCString()`;
         case "unixTimestamp":
-          return `${nullOrUndefinedPrefix}${clientValue}.getTime()`;
+          return `${nullOrUndefinedPrefix}((${clientValue}.getTime() / 1000) | 0)`;
         case "rfc3339":
         default:
           return `${getNullableCheck(clientValue, type)} ${clientValue}${
@@ -1086,7 +1086,7 @@ export function deserializeResponseValue(
       : "";
   switch (type.type) {
     case "datetime":
-      return `${nullOrUndefinedPrefix} new Date(${restValue})`;
+      return `${nullOrUndefinedPrefix} new Date(${type.format === "unixTimestamp" ? `${restValue} * 1000` : restValue})`;
     case "list": {
       const prefix = nullOrUndefinedPrefix + restValue;
       let elementNullOrUndefinedPrefix = "";

package/src/transform/transform.ts

@@ -46,6 +46,7 @@ export async function transformRLCModel(
 ): Promise<RLCModel> {
   const program = dpgContext.program;
   const options: RLCOptions = dpgContext.rlcOptions!;
+  const rlcSourceDir = dpgContext.generationPathDetail?.rlcSourcesDir;
   const srcPath = path.join(
     dpgContext.generationPathDetail?.rlcSourcesDir ?? "",
     options.batch && options.batch.length > 1
@@ -100,7 +101,8 @@ export async function transformRLCModel(
     importInfo: {
       internalImports: importSet,
       runtimeImports: buildRuntimeImports(options.flavor)
-    }
+    },
+    rlcSourceDir
   };
   model.sampleGroups = transformSampleGroups(
     model,

package/src/transform/transformApiVersionInfo.ts

@@ -86,7 +86,7 @@ export function getOperationApiVersion(
         relevantProperty: p.param
       });
       required.add(!p.param.optional);
-      if (p.type !== "header") {
+      if (p.type === "query" || p.type === "path") {
         locations.add(p.type);
       }
       const typeString = JSON.stringify(trimUsage(type));
@@ -127,7 +127,7 @@ export function getOperationApiVersion(
           relevantProperty: p.param
         });
         required.add(!p.param.optional);
-        if (p.type !== "header") {
+        if (p.type === "query" || p.type === "path") {
           locations.add(p.type);
         }
         const typeString = JSON.stringify(trimUsage(type));

package/src/transform/transformHelperFunctionDetails.ts

@@ -177,33 +177,19 @@ function extractSpecialSerializeInfo(
   dpgContext: SdkContext
 ) {
   let hasMultiCollection = false;
-  let hasPipeCollection = false;
-  let hasTsvCollection = false;
-  let hasSsvCollection = false;
   let hasCsvCollection = false;
   const clientOperations = listOperationsInOperationGroup(dpgContext, client);
   for (const clientOp of clientOperations) {
     const route = getHttpOperationWithCache(dpgContext, clientOp);
     route.parameters.parameters.forEach((parameter) => {
       const serializeInfo = getSpecialSerializeInfo(
+        dpgContext,
         parameter.type,
         (parameter as any).format
       );
       hasMultiCollection = hasMultiCollection
         ? hasMultiCollection
         : serializeInfo.hasMultiCollection;
-      hasPipeCollection = hasPipeCollection
-        ? hasPipeCollection
-        : serializeInfo.hasPipeCollection;
-      hasTsvCollection = hasTsvCollection
-        ? hasTsvCollection
-        : serializeInfo.hasTsvCollection;
-      hasSsvCollection = hasSsvCollection
-        ? hasSsvCollection
-        : serializeInfo.hasSsvCollection;
-      hasCsvCollection = hasCsvCollection
-        ? hasCsvCollection
-        : serializeInfo.hasCsvCollection;
     });
   }
   const operationGroups = listOperationGroups(dpgContext, client, true);
@@ -216,21 +202,13 @@ function extractSpecialSerializeInfo(
       const route = getHttpOperationWithCache(dpgContext, op);
       route.parameters.parameters.forEach((parameter) => {
         const serializeInfo = getSpecialSerializeInfo(
+          dpgContext,
           parameter.type,
           (parameter as any).format
         );
         hasMultiCollection = hasMultiCollection
           ? hasMultiCollection
           : serializeInfo.hasMultiCollection;
-        hasPipeCollection = hasPipeCollection
-          ? hasPipeCollection
-          : serializeInfo.hasPipeCollection;
-        hasTsvCollection = hasTsvCollection
-          ? hasTsvCollection
-          : serializeInfo.hasTsvCollection;
-        hasSsvCollection = hasSsvCollection
-          ? hasSsvCollection
-          : serializeInfo.hasSsvCollection;
         hasCsvCollection = hasCsvCollection
           ? hasCsvCollection
           : serializeInfo.hasCsvCollection;
@@ -239,9 +217,6 @@ function extractSpecialSerializeInfo(
   }
   return {
     hasMultiCollection,
-    hasPipeCollection,
-    hasTsvCollection,
-    hasSsvCollection,
     hasCsvCollection
   };
 }

package/src/transform/transformParameters.ts

@@ -29,14 +29,14 @@ import {
   listOperationGroups,
   listOperationsInOperationGroup
 } from "@azure-tools/typespec-client-generator-core";
-import { Type, isVoidType } from "@typespec/compiler";
+import { NoTarget, Type, isVoidType } from "@typespec/compiler";
 import {
   getBodyType,
   getFormattedPropertyDoc,
   getImportedModelName,
   getSchemaForType,
-  getSerializeTypeName,
   getTypeName,
+  isArrayType,
   isBodyRequired
 } from "../utils/modelUtils.js";
 import {
@@ -44,8 +44,16 @@ import {
   getOperationName,
   getSpecialSerializeInfo
 } from "../utils/operationUtil.js";
-
 import { SdkContext } from "../utils/interfaces.js";
+import { getParameterSerializationInfo } from "../utils/parameterUtils.js";
+import { reportDiagnostic } from "../lib.js";
+
+interface ParameterTransformationOptions {
+  apiVersionInfo?: ApiVersionInfo;
+  operationGroupName?: string;
+  operationName?: string;
+  importModels?: Set<string>;
+}
 
 export function transformToParameterTypes(
   client: SdkClient,
@@ -90,20 +98,27 @@ export function transformToParameterTypes(
       operationName: getOperationName(dpgContext, route.operation),
       parameters: []
     };
+    const options = {
+      apiVersionInfo,
+      operationGroupName: rlcParameter.operationGroup,
+      operationName: rlcParameter.operationName,
+      importModels: outputImportedSet
+    };
     // transform query param
     const queryParams = transformQueryParameters(
       dpgContext,
       parameters,
-      { apiVersionInfo },
-      outputImportedSet
+      options
     );
     // transform path param
-    const pathParams = transformPathParameters();
+    const pathParams = transformPathParameters(dpgContext, parameters, options);
+    // TODO: support cookie parameters, https://github.com/Azure/autorest.typescript/issues/2898
+    transformCookieParameters(dpgContext, parameters);
     // transform header param including content-type
     const headerParams = transformHeaderParameters(
       dpgContext,
       parameters,
-      outputImportedSet
+      options
     );
     // transform body
     const bodyType = getBodyType(route);
@@ -130,65 +145,62 @@ function getParameterMetadata(
   dpgContext: SdkContext,
   paramType: "query" | "path" | "header",
   parameter: HttpOperationParameter,
-  importedModels: Set<string>
+  options: ParameterTransformationOptions
 ): ParameterMetadata {
   const program = dpgContext.program;
+  const importedModels = options.importModels ?? new Set<string>();
   const schemaContext = [SchemaContext.Exception, SchemaContext.Input];
   const schema = getSchemaForType(dpgContext, parameter.param.type, {
     usage: schemaContext,
     needRef: false,
     relevantProperty: parameter.param
   }) as Schema;
-  let type = getTypeName(schema, schemaContext);
   const name = getParameterName(parameter.name);
   let description =
     getFormattedPropertyDoc(program, parameter.param, schema) ?? "";
-  if (
-    type === "string[]" ||
-    type === "Array<string>" ||
-    type === "number[]" ||
-    type === "Array<number>"
-  ) {
+  if (isArrayType(schema)) {
     const serializeInfo = getSpecialSerializeInfo(
+      dpgContext,
       parameter.type,
       (parameter as any).format
     );
-    if (
-      serializeInfo.hasMultiCollection ||
-      serializeInfo.hasPipeCollection ||
-      serializeInfo.hasSsvCollection ||
-      serializeInfo.hasTsvCollection ||
-      serializeInfo.hasCsvCollection
-    ) {
-      type = "string";
-      description += ` This parameter needs to be formatted as ${serializeInfo.collectionInfo.join(
+    if (serializeInfo.hasMultiCollection || serializeInfo.hasCsvCollection) {
+      description += `${description ? "\n" : ""}This parameter could be formatted as ${serializeInfo.collectionInfo.join(
         ", "
-      )} collection, we provide ${serializeInfo.descriptions.join(
+      )} collection string, we provide ${serializeInfo.descriptions.join(
         ", "
       )} from serializeHelper.ts to help${
         serializeInfo.hasMultiCollection
           ? ", you will probably need to set skipUrlEncoding as true when sending the request"
           : ""
-      }`;
+      }.`;
+    }
+    if ((parameter as any).format === "tsv") {
+      description += `${description ? "\n" : ""}This parameter could be formatted as tsv collection string.`;
     }
   }
-  type =
-    paramType !== "query" && type !== "string"
-      ? getSerializeTypeName(dpgContext.program, schema, schemaContext)
-      : type;
+
   getImportedModelName(schema, schemaContext)?.forEach(
     importedModels.add,
     importedModels
   );
+  const serializationType = getParameterSerializationInfo(
+    dpgContext,
+    parameter,
+    schema,
+    options.operationGroupName,
+    options.operationName
+  );
   return {
     type: paramType,
     name,
     param: {
       name,
-      type,
-      typeName: type,
+      type: serializationType.typeName,
+      typeName: serializationType.typeName,
       required: !parameter.param.optional,
-      description
+      description,
+      wrapperType: serializationType.wrapperType
     }
   };
 }
@@ -200,11 +212,29 @@ function getParameterName(name: string) {
   return `"${name}"`;
 }
 
+function transformCookieParameters(
+  dpgContext: SdkContext,
+  parameters: HttpOperationParameters
+) {
+  // TODO: support cookie parameters, https://github.com/Azure/autorest.typescript/issues/2898
+  parameters.parameters
+    .filter((p) => p.type === "cookie")
+    .forEach((p) => {
+      reportDiagnostic(dpgContext.program, {
+        code: "parameter-type-not-supported",
+        format: {
+          paramName: p.name,
+          paramType: p.type
+        },
+        target: NoTarget
+      });
+    });
+}
+
 function transformQueryParameters(
   dpgContext: SdkContext,
   parameters: HttpOperationParameters,
-  options: { apiVersionInfo: ApiVersionInfo | undefined },
-  importModels: Set<string> = new Set<string>()
+  options: ParameterTransformationOptions
 ): ParameterMetadata[] {
   const queryParameters = parameters.parameters.filter(
     (p) =>
@@ -218,7 +248,7 @@ function transformQueryParameters(
     return [];
   }
   return queryParameters.map((qp) =>
-    getParameterMetadata(dpgContext, "query", qp, importModels)
+    getParameterMetadata(dpgContext, "query", qp, options)
   );
 }
 
@@ -226,16 +256,27 @@ function transformQueryParameters(
  * Only support to take the global path parameter as path parameter
  * @returns
  */
-function transformPathParameters() {
-  // TODO
-  // issue tracked https://github.com/Azure/autorest.typescript/issues/1521
-  return [];
+function transformPathParameters(
+  dpgContext: SdkContext,
+  parameters: HttpOperationParameters,
+  options: ParameterTransformationOptions
+) {
+  // build wrapper path parameters
+  const pathParameters = parameters.parameters.filter((p) => p.type === "path");
+  if (!pathParameters.length) {
+    return [];
+  }
+  // only need to build path parameters for wrapper type
+  const params = pathParameters
+    .map((qp) => getParameterMetadata(dpgContext, "path", qp, options))
+    .filter((p) => p.param.wrapperType);
+  return params;
 }
 
 export function transformHeaderParameters(
   dpgContext: SdkContext,
   parameters: HttpOperationParameters,
-  importedModels: Set<string>
+  options: ParameterTransformationOptions
 ): ParameterMetadata[] {
   const headerParameters = parameters.parameters.filter(
     (p) => p.type === "header"
@@ -244,7 +285,7 @@ export function transformHeaderParameters(
     return [];
   }
   return headerParameters.map((qp) =>
-    getParameterMetadata(dpgContext, "header", qp, importedModels)
+    getParameterMetadata(dpgContext, "header", qp, options)
   );
 }
 

package/src/transform/transformPaths.ts

@@ -31,12 +31,12 @@ import {
 import {
   getImportedModelName,
   getSchemaForType,
-  getTypeName,
   isBodyRequired
 } from "../utils/modelUtils.js";
 
 import { SdkContext } from "../utils/interfaces.js";
 import { getDoc } from "@typespec/compiler";
+import { getParameterSerializationInfo } from "../utils/parameterUtils.js";
 
 export function transformPaths(
   client: SdkClient,
@@ -133,15 +133,33 @@ function transformOperation(
         .filter((p) => p.type === "path")
         .map((p) => {
           const schemaUsage = [SchemaContext.Input, SchemaContext.Exception];
+          const options = {
+            usage: schemaUsage,
+            needRef: false,
+            relevantProperty: p.param
+          };
           const schema = p.param.sourceProperty
-            ? getSchemaForType(dpgContext, p.param.sourceProperty?.type)
-            : getSchemaForType(dpgContext, p.param.type);
+            ? getSchemaForType(
+                dpgContext,
+                p.param.sourceProperty?.type,
+
+                options
+              )
+            : getSchemaForType(dpgContext, p.param.type, options);
           const importedNames = getImportedModelName(schema, schemaUsage) ?? [];
           importedNames.forEach(importSet.add, importSet);
+          const serializationType = getParameterSerializationInfo(
+            dpgContext,
+            p,
+            schema,
+            operationGroupName,
+            method.operationName
+          );
           return {
             name: p.name,
-            type: getTypeName(schema, schemaUsage),
-            description: getDoc(program, p.param)
+            type: serializationType.typeName,
+            description: getDoc(program, p.param) ?? "",
+            wrapperType: serializationType.wrapperType
           };
         }),
       operationGroupName: getOperationGroupName(dpgContext, route),