@azure-tools/typespec-ts 0.55.0-dev.10 → 0.55.0-dev.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@azure-tools/typespec-ts",
-  "version": "0.55.0-dev.10",
+  "version": "0.55.0-dev.11",
   "description": "An experimental TypeSpec emitter for TypeScript",
   "main": "dist/src/index.js",
   "type": "module",

package/src/modular/emit-samples.ts

@@ -316,12 +316,36 @@ function prepareExampleParameters(
 
   let subscriptionIdValue = `"00000000-0000-0000-0000-000000000000"`;
   let isSubscriptionIdAdded = false;
-  // required parameters
+
+  // Map each HTTP parameter to its method parameter via `methodParameterSegments`
+  // and place its example value at that path, yielding one argument per method
+  // parameter regardless of flat, nested, or grouped shape. Client- and
+  // body-carried roots are emitted by their own sections and skipped here.
+  const bodyParam = method.operation.bodyParam;
+  let bodyRootName: string | undefined;
+  if (
+    bodyParam &&
+    !isSpreadBodyParameter(bodyParam) &&
+    bodyParam.methodParameterSegments.length === 1 &&
+    bodyParam.methodParameterSegments[0] !== undefined &&
+    bodyParam.methodParameterSegments[0].length >= 1
+  ) {
+    bodyRootName = bodyParam.methodParameterSegments[0][0]!.name;
+  }
+
+  const methodArguments = new Map<
+    string,
+    { name: string; isOptional: boolean; value: ValueTreeNode | string }
+  >();
   for (const param of method.operation.parameters) {
-    if (param.optional === true || param.type.kind === "constant" || param.clientDefaultValue) {
+    if (param.type.kind === "constant" || param.clientDefaultValue) {
       continue;
     }
-
+    const path = param.methodParameterSegments[0];
+    if (path === undefined || path.length === 0) {
+      continue;
+    }
+    const root = path[0]!;
     const exampleValue = parameterMap[param.serializedName];
 
     // Handle subscriptionId parameter separately for ARM clients
@@ -343,28 +367,27 @@ function prepareExampleParameters(
       continue;
     }
 
+    // Roots emitted by the client and body sections.
+    if (root.onClient || (bodyRootName !== undefined && root.name === bodyRootName)) {
+      continue;
+    }
+
     if (!exampleValue || !exampleValue.value) {
       // report diagnostic if required parameter is missing
-      reportDiagnostic(dpgContext.program, {
-        code: "required-sample-parameter",
-        format: {
-          exampleName: method.oriName ?? method.name,
-          paramName: param.name,
-        },
-        target: NoTarget,
-      });
+      if (path.length === 1 && !param.optional) {
+        reportDiagnostic(dpgContext.program, {
+          code: "required-sample-parameter",
+          format: {
+            exampleName: method.oriName ?? method.name,
+            paramName: param.name,
+          },
+          target: NoTarget,
+        });
+      }
       continue;
     }
 
-    result.push(
-      prepareExampleValue(
-        dpgContext,
-        exampleValue.parameter.name,
-        exampleValue.value,
-        param.optional,
-        param.onClient,
-      ),
-    );
+    placeMethodArgument(methodArguments, path, getParameterValue(dpgContext, exampleValue.value));
   }
 
   // If client-level subscriptionId is needed on the client for this method, then add it
@@ -381,7 +404,6 @@ function prepareExampleParameters(
   }
 
   // required/optional body parameters
-  const bodyParam = method.operation.bodyParam;
   const bodySerializeName = bodyParam?.serializedName;
   const bodyExample = parameterMap[bodySerializeName ?? ""];
   if (bodyParam && bodyExample && bodyExample.value) {
@@ -441,28 +463,87 @@ function prepareExampleParameters(
       }
     }
   }
-  // optional parameters
-  method.operation.parameters
-    .filter(
-      (param) =>
-        param.optional === true && parameterMap[param.serializedName] && !param.clientDefaultValue,
-    )
-    .map((param) => parameterMap[param.serializedName]!)
-    .forEach((param) => {
-      result.push(
-        prepareExampleValue(
-          dpgContext,
-          param.parameter.name,
-          param.value,
-          true,
-          param.parameter.onClient,
-        ),
-      );
+  // Emit one argument per top-level method parameter. A normal parameter carries
+  // a scalar value; a parameter with nested leaves carries an object literal.
+  for (const arg of methodArguments.values()) {
+    result.push({
+      name: normalizeName(arg.name, NameType.Parameter, true),
+      value: serializeNestedValue(arg.value),
+      isOptional: arg.isOptional,
+      onClient: false,
     });
+  }
 
   return result;
 }
 
+/** A nested value tree: leaves are TypeScript value expressions, interior nodes are objects. */
+interface ValueTreeNode {
+  [key: string]: ValueTreeNode | string;
+}
+
+/**
+ * Records `leaf` for the method parameter addressed by `path`. `path[0]` is the
+ * top-level method parameter (the argument key); a single-segment path stores a
+ * scalar, a longer path stores the leaf inside a nested object merged with
+ * sibling leaves sharing the same root.
+ */
+function placeMethodArgument(
+  methodArguments: Map<
+    string,
+    { name: string; isOptional: boolean; value: ValueTreeNode | string }
+  >,
+  path: readonly { name: string; optional?: boolean }[],
+  leaf: string,
+): void {
+  const root = path[0]!;
+  let arg = methodArguments.get(root.name);
+  if (!arg) {
+    arg = { name: root.name, isOptional: Boolean(root.optional), value: {} };
+    methodArguments.set(root.name, arg);
+  }
+  if (path.length === 1) {
+    arg.value = leaf;
+    return;
+  }
+  if (typeof arg.value !== "object") {
+    arg.value = {};
+  }
+  setNestedValue(arg.value, path.slice(1), leaf);
+}
+
+/** Places `leaf` at `path` (segments after the root), creating intermediate objects as needed. */
+function setNestedValue(
+  root: ValueTreeNode,
+  path: readonly { name: string }[],
+  leaf: string,
+): void {
+  let node = root;
+  for (let i = 0; i < path.length; i++) {
+    const key = normalizeName(path[i]!.name, NameType.Property, true);
+    if (i === path.length - 1) {
+      node[key] = leaf;
+    } else {
+      const existing = node[key];
+      if (typeof existing !== "object" || existing === null) {
+        node[key] = {};
+      }
+      node = node[key] as ValueTreeNode;
+    }
+  }
+}
+
+/** Serializes a {@link ValueTreeNode} into a TypeScript object literal string. */
+function serializeNestedValue(node: ValueTreeNode | string): string {
+  if (typeof node === "string") {
+    return node;
+  }
+  const entries = Object.entries(node).map(
+    ([key, value]) => `${key}: ${serializeNestedValue(value)}`,
+  );
+  return `{ ${entries.join(", ")} }`;
+}
+
 function getCredentialExampleValue(
   _dpgContext: SdkContext,
   initialization: SdkClientInitializationType,