typespec-rust-emitter 0.3.0 → 0.4.0

package/CHANGELOG.md

@@ -5,6 +5,62 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.4.0] - 2026-03-27
+
+### Changed
+
+- **Breaking**: Server trait methods now accept individual parameters instead of request structs
+  - `async fn subjects_create(&self, claims: Self::Claims, request: SubjectsCreateRequest)` → `async fn subjects_create(&self, claims: Self::Claims, group_id: i64, body: CreateSubjectBody)`
+  - Path parameters extracted with `Path<T>` extractor
+  - Body extracted with `Json<T>` extractor
+  - Request structs (`SubjectsCreateRequest`, etc.) are no longer generated
+- **Breaking**: Extractor order in handlers follows axum conventions
+  - Order: `State` → `Extension` → `Path` → `Json`
+  - Fixes axum 0.8 `Handler` trait inference issues
+- Removed unused `Query` extractor import from generated code
+- Fixed decorator detection to use `getDecoratorName()` instead of direct property access
+
+### Benefits
+
+- Cleaner server trait API - no boilerplate request structs
+- Direct parameter access in handler implementations
+- Follows axum best practices for extractor ordering
+- Better IDE autocomplete for handler parameters
+
+### Example
+
+**TypeSpec:**
+
+```typespec
+@post
+@route("/groups/{groupId}/subjects")
+op create(@path groupId: int64, @body body: CreateSubjectBody): Subject;
+```
+
+**Before (v0.3.0):**
+
+```rust
+// Server trait
+async fn subjects_create(&self, claims: Self::Claims, request: SubjectsCreateRequest) -> Result<...>;
+
+// Handler
+axum::extract::Query(query): axum::extract::Query<SubjectsCreateRequest>
+let result = service.subjects_create(claims, query).await;
+```
+
+**After (v0.4.0):**
+
+```rust
+// Server trait
+async fn subjects_create(&self, claims: Self::Claims, group_id: i64, body: CreateSubjectBody) -> Result<...>;
+
+// Handler
+Extension(claims): Extension<S::Claims>,
+Path(group_id): Path<i64>,
+Json(payload): Json<CreateSubjectBody>
+let result = service.subjects_create(claims, group_id, payload).await;
+```
+
 ## [0.3.0] - 2026-03-27
 
 ### Added

package/QWEN.md

@@ -37,6 +37,7 @@ typespec-emitter/
 ## Build & Run Commands
 
 ### Primary Workflow (Run After Every Change)
+
 ```bash
 just build      # Compile TypeScript (npm run build)
 just test       # Run unit tests (npm test)
@@ -45,6 +46,7 @@ just check-rust # Verify Rust compiles (cargo check)
 ```
 
 ### Individual Commands
+
 ```bash
 # Development
 npm run build       # tsc compile
@@ -61,49 +63,52 @@ just publish        # build + npm publish
 
 ## Type Mappings (TypeSpec → Rust)
 
-| TypeSpec | Rust |
-|----------|------|
-| `string` | `String` |
-| `int8/16/32/64` | `i8/i16/i32/i64` |
-| `uint8/16/32/64` | `u8/u16/u32/u64` |
-| `float32/64` | `f32/f64` |
-| `boolean` | `bool` |
-| `bytes` | `Vec<u8>` |
-| `T[]` | `Vec<T>` |
-| `Record<T>` | `HashMap<String, T>` |
-| `T \| null` | `Option<T>` |
+| TypeSpec         | Rust                 |
+| ---------------- | -------------------- |
+| `string`         | `String`             |
+| `int8/16/32/64`  | `i8/i16/i32/i64`     |
+| `uint8/16/32/64` | `u8/u16/u32/u64`     |
+| `float32/64`     | `f32/f64`            |
+| `boolean`        | `bool`               |
+| `bytes`          | `Vec<u8>`            |
+| `T[]`            | `Vec<T>`             |
+| `Record<T>`      | `HashMap<String, T>` |
+| `T \| null`      | `Option<T>`          |
 
 ### Format Mappings
-| `@format()` | Rust Type |
-|-------------|-----------|
-| `"uuid"` | `uuid::Uuid` |
-| `"date"` | `chrono::NaiveDate` |
-| `"time"` | `chrono::NaiveTime` |
+
+| `@format()`   | Rust Type               |
+| ------------- | ----------------------- |
+| `"uuid"`      | `uuid::Uuid`            |
+| `"date"`      | `chrono::NaiveDate`     |
+| `"time"`      | `chrono::NaiveTime`     |
 | `"date-time"` | `chrono::DateTime<Utc>` |
 
 ## Decorators
 
-| Decorator | Effect |
-|-----------|--------|
-| `@error` | Adds `thiserror::Error` derive + `#[error("{code}: {message}")]` |
-| `@pattern("regex")` | Generates `TryFrom<String>` with regex validation |
-| `@rustDerive("...")` | Adds custom derive (models & enums, e.g., `sqlx::FromRow`, `sqlx::Type`) |
-| `@rustDerives("...", "...")` | Adds multiple custom derives (models & enums) |
-| `@rustAttr("...")` | Adds custom Rust attribute (models & enums, e.g., `sqlx(type_name = "...")`) |
-| `@rustAttrs("...", "...")` | Adds multiple custom attributes (models & enums) |
-| `@doc("...")` | Generates `///` doc comments |
-| `@useAuth(BearerAuth)` | Marks operation as protected (adds `Claims` param) |
-| `@maxLength(n)` | Documentation only |
+| Decorator                    | Effect                                                                       |
+| ---------------------------- | ---------------------------------------------------------------------------- |
+| `@error`                     | Adds `thiserror::Error` derive + `#[error("{code}: {message}")]`             |
+| `@pattern("regex")`          | Generates `TryFrom<String>` with regex validation                            |
+| `@rustDerive("...")`         | Adds custom derive (models & enums, e.g., `sqlx::FromRow`, `sqlx::Type`)     |
+| `@rustDerives("...", "...")` | Adds multiple custom derives (models & enums)                                |
+| `@rustAttr("...")`           | Adds custom Rust attribute (models & enums, e.g., `sqlx(type_name = "...")`) |
+| `@rustAttrs("...", "...")`   | Adds multiple custom attributes (models & enums)                             |
+| `@doc("...")`                | Generates `///` doc comments                                                 |
+| `@useAuth(BearerAuth)`       | Marks operation as protected (adds `Claims` param)                           |
+| `@maxLength(n)`              | Documentation only                                                           |
 
 ## Output Files
 
 ### types.rs
+
 - All models → `pub struct` with serde derives
 - Enums → `pub enum` with serde rename
 - Unions → `Option<T>` for nullable, or sum types
 - Scalars → `pub type` or `pub struct` (if pattern validation)
 
 ### server.rs
+
 - `Server` trait with `type Claims` associated type
 - Request structs per operation
 - Response enums with status code variants
@@ -112,6 +117,7 @@ just publish        # build + npm publish
 ## Key Implementation Details
 
 ### emitter.ts Architecture
+
 1. `navigateProgram()` - Walks TypeSpec AST
 2. Collects: models, enums, unions, scalars, operations
 3. Processes decorators (`@error`, `@pattern`, `@rustDerive`)
@@ -119,15 +125,19 @@ just publish        # build + npm publish
 5. Emits files to configured output directory
 
 ### Server Trait Generation
+
 - Generates `Server` trait with `type Claims: Send + Sync + 'static` associated type
-- Handler functions: `pub async fn {op}_handler<S>(...)` with `<S>` generics only
+- Handler functions accept individual parameters (path params, body) directly
+- Path params extracted with `Path<T>`
+- Body extracted with `Json<T>`
 - Protected routes (`@useAuth`) receive `claims: Self::Claims` via `Extension<Self::Claims>`
-- Public routes don't require claims
+- Extractor order: `State` → `Extension` → `Path` → `Json`
 - `create_router<S, M>(service: S, middleware: M)` accepts middleware function
 - Middleware wraps protected routes: `middleware(protected)`
 - Router merges public/protected, applies `.with_state(service)` once at end
 
 ### Test Pattern
+
 ```typescript
 import { emit } from "./test-host.js";
 const results = await emit(`model User { name: string; }`);
@@ -138,15 +148,18 @@ strictEqual(output.includes("pub struct User"), true);
 ## Dependencies
 
 ### Peer (Required)
+
 - `@typespec/compiler` >=1.0.0
 - `@typespec/emitter-framework` ^0.17.0
 
 ### Dev
+
 - `typescript` ^5.3.3
 - `eslint` ^9.15.0
 - `prettier` ^3.3.3
 
 ### Generated Rust (example/output-rust/Cargo.toml)
+
 ```toml
 serde = { version = "1.0", features = ["derive"] }
 thiserror = "2.0"
@@ -163,6 +176,7 @@ tokio = { version = "1.50", features = ["full"] }
 ## Configuration Files
 
 ### tspconfig.yaml
+
 ```yaml
 emit:
   - "@typespec/openapi3"
@@ -173,6 +187,7 @@ options:
 ```
 
 ### tsconfig.json
+
 - Target: ES2022
 - Module: NodeNext
 - Strict: true
@@ -196,14 +211,51 @@ options:
 
 ## Recent Changes
 
+### 2026-03-27: v0.4.0 - Individual Parameters Instead of Request Structs
+
+**Breaking Changes**:
+
+- Server trait methods now accept individual parameters instead of request structs
+  - `async fn subjects_create(&self, claims: Self::Claims, request: SubjectsCreateRequest)` → `async fn subjects_create(&self, claims: Self::Claims, group_id: i64, body: CreateSubjectBody)`
+- Request structs (`SubjectsCreateRequest`, etc.) are no longer generated
+- Handler extractor order follows axum conventions: `State` → `Extension` → `Path` → `Json`
+
+**Benefits**:
+
+- Cleaner server trait API - no boilerplate request structs
+- Direct parameter access in handler implementations
+- Follows axum best practices for extractor ordering
+- Better IDE autocomplete for handler parameters
+
+**Example**:
+
+```typespec
+@post
+@route("/groups/{groupId}/subjects")
+op create(@path groupId: int64, @body body: CreateSubjectBody): Subject;
+```
+
+```rust
+// Server trait
+async fn subjects_create(&self, claims: Self::Claims, group_id: i64, body: CreateSubjectBody) -> Result<...>;
+
+// Handler
+Extension(claims): Extension<S::Claims>,
+Path(group_id): Path<i64>,
+Json(payload): Json<CreateSubjectBody>
+let result = service.subjects_create(claims, group_id, payload).await;
+```
+
 ### 2026-03-27: v0.3.0 - Custom Attributes & Enum Derives
 
 **New Features**:
+
 - `@rustAttr` / `@rustAttrs` decorators for custom Rust attributes (models & enums)
 - `@rustDerive` / `@rustDerives` now work on enums (previously models only)
 - Attributes render after `#[derive(...)]` for proper Rust syntax
 
 **Example**:
+
 ```typespec
 @rustDerive("sqlx::Type")
 @rustAttr("sqlx(type_name = \"study_status\")")
@@ -219,6 +271,7 @@ pub enum StudyStatus { ... }
 ### 2026-03-27: v0.2.0 - Server Trait Refactoring
 
 **Changes**:
+
 - `pub trait Server<Claims>` → `pub trait Server` with `type Claims` associated type
 - Removed generated `Claims` struct from `types.rs` (users define their own)
 - `create_router<S, M>(service: S, middleware: M)` now accepts middleware function
@@ -226,6 +279,7 @@ pub enum StudyStatus { ... }
 - Single `.with_state(service)` call at end of router creation
 
 **Benefits**:
+
 - Cleaner API - Claims type defined by user, not generated
 - Flexible middleware - any function `FnOnce(Router<S>) -> Router<S>`
 - No duplicate `.with_state(service.clone())` calls

package/README.md

@@ -248,9 +248,9 @@ namespace Groups {
 pub trait Server: Send + Sync {
     type Claims: Send + Sync + 'static;
 
-    async fn groups_list(&self, request: GroupsListRequest) -> Result<GroupsListResponse>;
-    async fn groups_create(&self, claims: Self::Claims, request: GroupsCreateRequest) -> Result<GroupsCreateResponse>;
-    async fn groups_get_by_id(&self, request: GroupsGetByIdRequest) -> Result<GroupsGetByIdResponse>;
+    async fn groups_list(&self) -> Result<GroupsListResponse>;
+    async fn groups_create(&self, claims: Self::Claims, body: CreateGroupBody) -> Result<GroupsCreateResponse>;
+    async fn groups_get_by_id(&self, id: i64) -> Result<GroupsGetByIdResponse>;
 }
 ```
 
@@ -270,10 +270,7 @@ pub struct MyServer {
 impl Server for MyServer {
     type Claims = Claims; // Your custom claims type
 
-    async fn groups_list(
-        &self,
-        _request: GroupsListRequest,
-    ) -> eyre::Result<GroupsListResponse> {
+    async fn groups_list(&self) -> eyre::Result<GroupsListResponse> {
         let groups = sqlx::query_as::<_, Group>("SELECT * FROM groups")
             .fetch_all(&self.state.db)
             .await?;
@@ -283,19 +280,29 @@ impl Server for MyServer {
     async fn groups_create(
         &self,
         claims: Self::Claims,
-        request: GroupsCreateRequest,
+        body: CreateGroupBody,
     ) -> eyre::Result<GroupsCreateResponse> {
-        // claims.sub contains the authenticated user ID
+        // Direct access to body fields
         let group = sqlx::query_as::<_, Group>(
             "INSERT INTO groups (name, owner_id) VALUES ($1, $2) RETURNING *"
         )
-        .bind(&request.body.name)
+        .bind(&body.name)
         .bind(&claims.sub)
         .fetch_one(&self.state.db)
         .await?;
         Ok(GroupsCreateResponse::Created(Json(group)))
     }
 
+    async fn groups_get_by_id(&self, id: i64) -> eyre::Result<GroupsGetByIdResponse> {
+        // Direct access to path parameter
+        let group = sqlx::query_as::<_, Group>("SELECT * FROM groups WHERE id = $1")
+            .bind(id)
+            .fetch_optional(&self.state.db)
+            .await?
+            .ok_or_else(|| GroupsGetByIdResponse::NotFound)?;
+        Ok(GroupsGetByIdResponse::Ok(Json(group)))
+    }
+
     // ... implement other methods
 }
 ```
@@ -372,16 +379,16 @@ Public routes do not receive claims and are not wrapped with auth middleware.
 
 ## Decorators
 
-| Decorator                    | Description                                                      |
-| ---------------------------- | ---------------------------------------------------------------- |
-| `@error`                     | Adds `thiserror::Error` derive with error message                |
-| `@pattern("regex")`          | Generates `TryFrom<String>` with regex validation                |
-| `@rustDerive("...")`         | Adds a custom derive macro (models & enums)                      |
-| `@rustDerives("...", "...")` | Adds multiple custom derive macros (models & enums)              |
-| `@rustAttr("...")`           | Adds a custom Rust attribute (models & enums)                    |
-| `@rustAttrs("...", "...")`   | Adds multiple custom Rust attributes (models & enums)            |
-| `@doc("...")`                | Generates `///` doc comments                                     |
-| `@useAuth(AuthType)`         | Marks operation as protected, adds `Claims` parameter            |
+| Decorator                    | Description                                           |
+| ---------------------------- | ----------------------------------------------------- |
+| `@error`                     | Adds `thiserror::Error` derive with error message     |
+| `@pattern("regex")`          | Generates `TryFrom<String>` with regex validation     |
+| `@rustDerive("...")`         | Adds a custom derive macro (models & enums)           |
+| `@rustDerives("...", "...")` | Adds multiple custom derive macros (models & enums)   |
+| `@rustAttr("...")`           | Adds a custom Rust attribute (models & enums)         |
+| `@rustAttrs("...", "...")`   | Adds multiple custom Rust attributes (models & enums) |
+| `@doc("...")`                | Generates `///` doc comments                          |
+| `@useAuth(AuthType)`         | Marks operation as protected, adds `Claims` parameter |
 
 ## Building
 

package/dist/src/emitter.js

@@ -149,24 +149,46 @@ function getOperationParameters(program, operation, anonymousEnums) {
     const model = operation.parameters;
     for (const [propName, prop] of model.properties) {
         const decorators = prop.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 = "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";
             }
         }
         const { type: rustType } = getRustTypeForProperty(prop.type, program, anonymousEnums);
@@ -184,8 +206,14 @@ function getOperationParameters(program, operation, anonymousEnums) {
 function getOperationBody(operation) {
     for (const [_propName, prop] of operation.parameters.properties) {
         const decorators = prop.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;
@@ -350,6 +378,8 @@ function generateServerTrait(program, namespaceGroups, anonymousEnums) {
     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]
@@ -366,53 +396,44 @@ pub trait Server: Send + Sync {
             if (opInfo.doc) {
                 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);
+            // Build parameter list for the trait method
+            const paramParts = [];
+            // 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);
+                paramParts.push(`body: ${bodyType.type}`);
+            }
+            const paramsStr = paramParts.join(", ");
             if (isProtected) {
-                parts.push(`    async fn ${fnName}(&self, claims: Self::Claims, request: ${requestName}) -> Result<${responseName}>;`);
+                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 {
-                parts.push(`    async fn ${fnName}(&self, request: ${requestName}) -> Result<${responseName}>;`);
+                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");
 }
-function generateRequestStructs(program, namespaceGroups, anonymousEnums) {
-    const parts = [];
-    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 = [];
-            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},`);
-            }
-            if (opInfo.body) {
-                const bodyType = getRustTypeForProperty(opInfo.body.type, program, anonymousEnums);
-                fields.push(`  #[serde(rename = "body")]`);
-                fields.push(`  pub body: ${bodyType.type},`);
-            }
-            parts.push(`#[derive(Debug, Clone, serde::Deserialize)]
-pub struct ${requestName} {
-${fields.join("\n")}
-}
-`);
-        }
-    }
-    return parts.join("\n");
-}
 function generateResponseEnums(program, namespaceGroups, anonymousEnums) {
     const parts = [];
     for (const group of namespaceGroups) {
@@ -478,71 +499,45 @@ function generateRouter(program, namespaceGroups, anonymousEnums) {
             usedMethods.add(method);
             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 = [];
-            let requestExpr = "";
+            const serverArgs = [];
+            // 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})>,`);
+                    extractorLines.push(`    Path((${pathFields})): Path<(${pathTypes})>,`);
                 }
-            }
-            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>,`);
-            }
-            // 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";
+                // Add path params to server method args
+                for (const param of pathParams) {
+                    serverArgs.push(param.rustName);
                 }
             }
-            else if (hasBody) {
-                if (hasPathParams) {
-                    const pathAssignments = pathParams
-                        .map((p) => `${p.rustName},`)
-                        .join(" ");
-                    requestExpr = `${requestName} { ${pathAssignments} body }`;
-                }
-                else {
-                    requestExpr = `${requestName} { body }`;
-                }
-            }
-            else {
-                requestExpr = `${requestName} {}`;
+            // 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`);
             }
-            // 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>(
     axum::extract::State(service): axum::extract::State<S>,
@@ -1118,15 +1113,9 @@ export async function $onEmit(context, _options) {
     });
     if (namespaceGroups.length > 0) {
         const serverTrait = generateServerTrait(context.program, namespaceGroups, anonymousEnums);
-        const requestStructs = generateRequestStructs(context.program, namespaceGroups, anonymousEnums);
         const responseEnums = generateResponseEnums(context.program, namespaceGroups, anonymousEnums);
         const router = generateRouter(context.program, namespaceGroups, 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"),
             content: serverContent,