typespec-rust-emitter 0.3.0 → 0.4.0

package/src/emitter.ts

@@ -245,22 +245,45 @@ function getOperationParameters(
 
   for (const [propName, prop] of model.properties) {
     const decorators = (prop as any).decorators;
+
+    // Skip body parameters - they are handled separately
+    let isBody = false;
+    if (decorators) {
+      for (const key of Object.keys(decorators)) {
+        const decorator = decorators[key];
+        const name = getDecoratorName(decorator);
+        if (name === "body" || name === "bodyRoot") {
+          isBody = true;
+          break;
+        }
+      }
+    }
+    if (isBody) continue;
+
     let location: "path" | "query" | "header" | "cookie" = "query";
     let rustName = toRustIdent(propName);
 
     if (decorators) {
-      if (decorators["$path"]) {
-        location = "path";
-      } else if (decorators["$query"]) {
-        location = "query";
-      } else if (decorators["$header"]) {
-        location = "header";
-        const headerDec = decorators["$header"];
-        if (headerDec?.value) {
-          rustName = headerDec.value;
+      for (const key of Object.keys(decorators)) {
+        const decorator = decorators[key];
+        const name = getDecoratorName(decorator);
+        if (name === "path") {
+          location = "path";
+          break;
+        } else if (name === "query") {
+          location = "query";
+          break;
+        } else if (name === "header") {
+          location = "header";
+          const headerVal = getDecoratorArgValue(decorator, 0);
+          if (headerVal) {
+            rustName = toRustIdent(headerVal);
+          }
+          break;
+        } else if (name === "cookie") {
+          location = "cookie";
+          break;
         }
-      } else if (decorators["$cookie"]) {
-        location = "cookie";
       }
     }
 
@@ -286,8 +309,14 @@ function getOperationParameters(
 function getOperationBody(operation: Operation): ModelProperty | undefined {
   for (const [_propName, prop] of operation.parameters.properties) {
     const decorators = (prop as any).decorators;
-    if (decorators?.["$body"] || decorators?.["$bodyRoot"]) {
-      return prop;
+    if (!decorators) continue;
+
+    for (const key of Object.keys(decorators)) {
+      const decorator = decorators[key];
+      const name = getDecoratorName(decorator);
+      if (name === "body" || name === "bodyRoot") {
+        return prop;
+      }
     }
   }
   return undefined;
@@ -491,6 +520,8 @@ function generateServerTrait(
   parts.push(`use super::types::*;
 use async_trait::async_trait;
 use axum::{http::StatusCode, Json};
+use axum::extract::Path;
+use axum::Extension;
 use eyre::Result;
 
 #[async_trait]
@@ -512,75 +543,58 @@ pub trait Server: Send + Sync {
         parts.push(`    ${formatDoc(opInfo.doc)}`);
       }
 
-      const requestName = `${nsName}${toPascalCase(opInfo.name)}Request`;
       const responseName = `${nsName}${toPascalCase(opInfo.name)}Response`;
       const fnName = toRustIdent(`${nsName}_${opInfo.name}`);
       const isProtected = hasAuthDecorator(op);
 
-      if (isProtected) {
-        parts.push(
-          `    async fn ${fnName}(&self, claims: Self::Claims, request: ${requestName}) -> Result<${responseName}>;`,
-        );
-      } else {
-        parts.push(
-          `    async fn ${fnName}(&self, request: ${requestName}) -> Result<${responseName}>;`,
-        );
-      }
-    }
-  }
-
-  parts.push("}");
-
-  return parts.join("\n");
-}
+      // Build parameter list for the trait method
+      const paramParts: string[] = [];
 
-function generateRequestStructs(
-  program: Program,
-  namespaceGroups: { namespace: Namespace; operations: Operation[] }[],
-  anonymousEnums: Map<string, AnonymousStringLiteralUnion>,
-): string {
-  const parts: string[] = [];
-
-  for (const group of namespaceGroups) {
-    const nsName = toPascalCase(
-      group.namespace.name.replace(/[^a-zA-Z0-9_]/g, "_"),
-    );
-
-    for (const op of group.operations) {
-      const opInfo = emitOperationInfo(program, op, "", anonymousEnums);
-      if (!opInfo) continue;
-
-      const params = opInfo.parameters;
-      const requestName = `${nsName}${toPascalCase(opInfo.name)}Request`;
-
-      const fields: string[] = [];
-
-      for (const param of params) {
-        const rustType = param.optional
-          ? `Option<${param.rustType}>`
-          : param.rustType;
-        fields.push(`  #[serde(rename = "${param.name}", flatten)]`);
-        fields.push(`  pub ${param.rustName}: ${rustType},`);
+      // Add path parameters
+      for (const param of opInfo.parameters) {
+        if (param.location === "path") {
+          paramParts.push(`${param.rustName}: ${param.rustType}`);
+        }
       }
 
+      // Add body parameter
       if (opInfo.body) {
         const bodyType = getRustTypeForProperty(
           opInfo.body.type,
           program,
           anonymousEnums,
         );
-        fields.push(`  #[serde(rename = "body")]`);
-        fields.push(`  pub body: ${bodyType.type},`);
+        paramParts.push(`body: ${bodyType.type}`);
       }
 
-      parts.push(`#[derive(Debug, Clone, serde::Deserialize)]
-pub struct ${requestName} {
-${fields.join("\n")}
-}
-`);
+      const paramsStr = paramParts.join(", ");
+
+      if (isProtected) {
+        if (paramsStr) {
+          parts.push(
+            `    async fn ${fnName}(&self, claims: Self::Claims, ${paramsStr}) -> Result<${responseName}>;`,
+          );
+        } else {
+          parts.push(
+            `    async fn ${fnName}(&self, claims: Self::Claims) -> Result<${responseName}>;`,
+          );
+        }
+      } else {
+        if (paramsStr) {
+          parts.push(
+            `    async fn ${fnName}(&self, ${paramsStr}) -> Result<${responseName}>;`,
+          );
+        } else {
+          parts.push(
+            `    async fn ${fnName}(&self) -> Result<${responseName}>;`,
+          );
+        }
+      }
     }
   }
 
+  parts.push("}");
+
   return parts.join("\n");
 }
 
@@ -672,83 +686,57 @@ function generateRouter(
 
       const handlerFnName = toRustIdent(`${nsName}_${opInfo.name}`);
       const traitFnName = handlerFnName;
-      const requestName = `${nsName}${toPascalCase(opInfo.name)}Request`;
       const isProtected = hasAuthDecorator(op);
 
       const pathParams = opInfo.parameters.filter((p) => p.location === "path");
-      const queryParams = opInfo.parameters.filter(
-        (p) => p.location === "query",
-      );
       const hasPathParams = pathParams.length > 0;
-      const hasQueryParams = queryParams.length > 0;
       const hasBody = !!opInfo.body;
 
-      // Build extractor lines and request construction expression
+      // Build extractor lines and server method call arguments
+      // IMPORTANT: axum requires specific extractor order:
+      // State -> Extension -> Path -> Query -> Json -> Body
       const extractorLines: string[] = [];
-      let requestExpr = "";
+      const serverArgs: string[] = [];
+
+      // State is always first (added in handler template)
+
+      // Extension (claims) comes after State
+      if (isProtected) {
+        extractorLines.push(`    Extension(claims): Extension<S::Claims>,`);
+        serverArgs.push(`claims`);
+      }
 
+      // Path params come after Extension
       if (hasPathParams) {
         const pathTypes = pathParams.map((p) => p.rustType).join(", ");
         const pathFields = pathParams.map((p) => p.rustName).join(", ");
         if (pathParams.length === 1) {
-          extractorLines.push(
-            `    axum::extract::Path(${pathFields}): axum::extract::Path<${pathTypes}>,`,
-          );
+          extractorLines.push(`    Path(${pathFields}): Path<${pathTypes}>,`);
         } else {
           extractorLines.push(
-            `    axum::extract::Path((${pathFields})): axum::extract::Path<(${pathTypes})>,`,
+            `    Path((${pathFields})): Path<(${pathTypes})>,`,
           );
         }
+        // Add path params to server method args
+        for (const param of pathParams) {
+          serverArgs.push(param.rustName);
+        }
       }
 
-      if (hasQueryParams) {
-        extractorLines.push(
-          `    axum::extract::Query(query): axum::extract::Query<${requestName}>,`,
-        );
-      } else if (hasBody) {
-        extractorLines.push(
-          `    axum::Json(body): axum::Json<${requestName}Body>,`,
-        );
-      }
-
-      if (isProtected) {
-        extractorLines.push(
-          `    axum::Extension(claims): axum::Extension<S::Claims>,`,
+      // Json body comes last
+      if (hasBody && opInfo.body) {
+        const bodyType = getRustTypeForProperty(
+          opInfo.body.type,
+          program,
+          anonymousEnums,
         );
+        extractorLines.push(`    Json(payload): Json<${bodyType.type}>,`);
+        serverArgs.push(`payload`);
       }
 
-      // Build request struct expression
-      if (hasOnlyPathParams(hasPathParams, hasQueryParams, hasBody)) {
-        const pathAssignments = pathParams
-          .map((p) => `${p.rustName},`)
-          .join(" ");
-        requestExpr = `${requestName} { ${pathAssignments} }`;
-      } else if (hasQueryParams) {
-        if (hasPathParams) {
-          const pathAssignments = pathParams
-            .map((p) => `${p.rustName},`)
-            .join(" ");
-          requestExpr = `${requestName} { ${pathAssignments} ..query }`;
-        } else {
-          requestExpr = "query";
-        }
-      } else if (hasBody) {
-        if (hasPathParams) {
-          const pathAssignments = pathParams
-            .map((p) => `${p.rustName},`)
-            .join(" ");
-          requestExpr = `${requestName} { ${pathAssignments} body }`;
-        } else {
-          requestExpr = `${requestName} { body }`;
-        }
-      } else {
-        requestExpr = `${requestName} {}`;
-      }
-
-      // Server method call
-      const serverCall = isProtected
-        ? `service.${traitFnName}(claims, ${requestExpr}).await`
-        : `service.${traitFnName}(${requestExpr}).await`;
+      // Build server method call
+      const serverArgsStr = serverArgs.join(", ");
+      const serverCall = `service.${traitFnName}(${serverArgsStr}).await`;
 
       // All handlers use <S> generics, Claims is now an associated type
       let handlerCode = `pub async fn ${handlerFnName}_handler<S>(
@@ -1172,9 +1160,7 @@ function emitModel(
     parts.push('#[error("{code}: {message}")]');
   }
 
-  const customAttrs = (model as any)[rustAttrKey] as
-    | RustAttrInfo
-    | undefined;
+  const customAttrs = (model as any)[rustAttrKey] as RustAttrInfo | undefined;
   if (customAttrs) {
     for (const attr of customAttrs.attrs) {
       parts.push(`#[${attr}]`);
@@ -1277,9 +1263,7 @@ function emitEnum(enumType: Enum): string {
   }
 
   if (isString) {
-    parts.push(
-      `#[derive(${allDerives.join(", ")})]`,
-    );
+    parts.push(`#[derive(${allDerives.join(", ")})]`);
     if (attrLines.length > 0) {
       parts.push(...attrLines);
     }
@@ -1291,9 +1275,7 @@ function emitEnum(enumType: Enum): string {
       parts.push(`  ${variantName},`);
     }
   } else {
-    parts.push(
-      `#[derive(${allDerives.join(", ")})]`,
-    );
+    parts.push(`#[derive(${allDerives.join(", ")})]`);
     if (attrLines.length > 0) {
       parts.push(...attrLines);
     }
@@ -1507,11 +1489,6 @@ export async function $onEmit(
       namespaceGroups,
       anonymousEnums,
     );
-    const requestStructs = generateRequestStructs(
-      context.program,
-      namespaceGroups,
-      anonymousEnums,
-    );
     const responseEnums = generateResponseEnums(
       context.program,
       namespaceGroups,
@@ -1523,12 +1500,7 @@ export async function $onEmit(
       anonymousEnums,
     );
 
-    const serverContent = [
-      serverTrait,
-      requestStructs,
-      responseEnums,
-      router,
-    ].join("\n");
+    const serverContent = [serverTrait, responseEnums, router].join("\n");
 
     await emitFile(context.program, {
       path: resolvePath(context.emitterOutputDir, "server.rs"),