typespec-rust-emitter 0.13.0 → 0.14.0

package/example/output-rust/src/generated/server.rs

@@ -12,11 +12,12 @@ use eyre::Result;
 
 /// Pluggable ETag cache backend.
 /// Implement this for Redis, Memcached, in-memory HashMap, or any store.
+#[async_trait]
 pub trait EtagCache {
     /// Return the stored ETag string for `key`, or `None` if not cached.
-    fn get(&self, key: &str) -> Option<String>;
+    async fn get(&self, key: &str) -> Option<String>;
     /// Store `etag` under `key`.
-    fn set(&self, key: &str, etag: &str);
+    async fn set(&self, key: &str, etag: &str);
 }
 
 
@@ -28,12 +29,20 @@ pub trait Server: Send + Sync {
 
     async fn events_accounts_events(&self, account_id: String) -> Result<EventsAccountsEventsResponse>;
     async fn pets_list(&self, first_query: String, second_query: String) -> Result<PetsListResponse>;
-    async fn items_list(&self) -> Result<ItemsListResponse>;
+    async fn items_list<C: EtagCache + Send + Sync>(
+        &self, cache: &C
+    ) -> Result<ItemsListResponse>;
     async fn items_get_item(&self, id: String) -> Result<ItemsGetItemResponse>;
     async fn items_create_item(&mut self, body: Item) -> Result<ItemsCreateItemResponse>;
     async fn items_update_item(&mut self, id: String, body: Item) -> Result<ItemsUpdateItemResponse>;
+    async fn images_list_public<C: EtagCache + Send + Sync>(
+        &self, cache: &C, account_id: uuid::Uuid
+    ) -> Result<ImagesListPublicResponse>;
+    async fn images_get_image<C: EtagCache + Send + Sync>(
+        &self, cache: &C, account_id: uuid::Uuid, image_id: String
+    ) -> Result<ImagesGetImageResponse>;
     async fn articles_get_article<C: EtagCache + Send + Sync>(
-        &self, cache: &C, id: String
+        &self, claims: Self::Claims, cache: &C, id: String
     ) -> Result<ArticlesGetArticleResponse>;
     async fn consuming_consume_and_delete(self, id: String) -> Result<ConsumingConsumeAndDeleteResponse>;
     async fn consuming_upload(&self, account_id: uuid::Uuid, body: Multipart) -> Result<ConsumingUploadResponse>;
@@ -122,6 +131,38 @@ impl IntoResponse for ItemsUpdateItemResponse {
     }
 }
 
+#[allow(clippy::type_complexity)]
+pub enum ImagesListPublicResponse {
+    Ok(Json<Vec<Item>>),
+    NotModified,
+}
+
+impl IntoResponse for ImagesListPublicResponse {
+    fn into_response(self) -> axum::response::Response {
+        match self {
+
+            ImagesListPublicResponse::Ok(body) => (StatusCode::OK, body).into_response(),
+            ImagesListPublicResponse::NotModified => StatusCode::NOT_MODIFIED.into_response(),
+        }
+    }
+}
+
+#[allow(clippy::type_complexity)]
+pub enum ImagesGetImageResponse {
+    Ok(Json<Item>),
+    NotModified,
+}
+
+impl IntoResponse for ImagesGetImageResponse {
+    fn into_response(self) -> axum::response::Response {
+        match self {
+
+            ImagesGetImageResponse::Ok(body) => (StatusCode::OK, body).into_response(),
+            ImagesGetImageResponse::NotModified => StatusCode::NOT_MODIFIED.into_response(),
+        }
+    }
+}
+
 #[allow(clippy::type_complexity)]
 pub enum ArticlesGetArticleResponse {
     Ok(Json<Article>),
@@ -235,22 +276,38 @@ where
     }
 }
 
-pub async fn items_list_handler<S>(
+pub async fn items_list_handler<S, C>(
     axum::extract::State(service): axum::extract::State<S>,
-
+    axum::extract::State(cache): axum::extract::State<C>,
+    if_none_match: Option<axum_extra::TypedHeader<axum_extra::headers::IfNoneMatch>>,
 ) -> impl axum::response::IntoResponse
 where
-    S: Server+ Clone + Send + Sync + 'static,
+    S: Server + Send + Sync + 'static,
     S::Claims: Send + Sync + Clone + 'static,
+    C: EtagCache + Clone + Send + Sync + 'static,
 {
-    let result = service.items_list().await;
+    // Check If-None-Match against the cache
+    let cache_key = "article-list";
+    if let (Some(stored_etag), Some(axum_extra::TypedHeader(inm))) =
+        (cache.get(cache_key.as_ref()).await, if_none_match)
+        && let Ok(etag) = stored_etag.parse::<axum_extra::headers::ETag>()
+        && !inm.precondition_passes(&etag)
+    {
+        let mut res = axum::http::StatusCode::NOT_MODIFIED.into_response();
+        res.headers_mut().insert(axum::http::header::CACHE_CONTROL, axum::http::HeaderValue::from_static("public, max-age=3600"));
+        return res;
+    }
+    // Forward to business logic
+    let result = service.items_list(&cache).await;
     match result {
         Ok(response) => {
             let mut res = response.into_response();
-            res.headers_mut().insert(
-                axum::http::header::CACHE_CONTROL,
-                axum::http::HeaderValue::from_static("no-cache"),
-            );
+            if let Some(stored_etag) = cache.get(cache_key.as_ref()).await
+                && let Ok(etag) = axum::http::HeaderValue::from_str(&stored_etag)
+            {
+                res.headers_mut().insert(axum::http::header::ETAG, etag);
+            }
+            res.headers_mut().insert(axum::http::header::CACHE_CONTROL, axum::http::HeaderValue::from_static("public, max-age=3600"));
             res
         }
         Err(e) => (
@@ -271,7 +328,14 @@ where
 {
     let result = service.items_get_item(id).await;
     match result {
-        Ok(response) => response.into_response(),
+        Ok(response) => {
+            let mut res = response.into_response();
+            res.headers_mut().insert(
+                axum::http::header::CACHE_CONTROL,
+                axum::http::HeaderValue::from_static("no-cache"),
+            );
+            res
+        }
         Err(e) => (
             axum::http::StatusCode::INTERNAL_SERVER_ERROR,
             format!("Internal error: {e}"),
@@ -319,36 +383,124 @@ where
     }
 }
 
+pub async fn images_list_public_handler<S, C>(
+    axum::extract::State(service): axum::extract::State<S>,
+    axum::extract::State(cache): axum::extract::State<C>,
+    if_none_match: Option<axum_extra::TypedHeader<axum_extra::headers::IfNoneMatch>>,
+    Path(account_id): Path<uuid::Uuid>,
+) -> impl axum::response::IntoResponse
+where
+    S: Server + Send + Sync + 'static,
+    S::Claims: Send + Sync + Clone + 'static,
+    C: EtagCache + Clone + Send + Sync + 'static,
+{
+    // Check If-None-Match against the cache
+    let cache_key = format!("img:list:pub:{account_id}");
+    if let (Some(stored_etag), Some(axum_extra::TypedHeader(inm))) =
+        (cache.get(cache_key.as_ref()).await, if_none_match)
+        && let Ok(etag) = stored_etag.parse::<axum_extra::headers::ETag>()
+        && !inm.precondition_passes(&etag)
+    {
+        let mut res = axum::http::StatusCode::NOT_MODIFIED.into_response();
+        res.headers_mut().insert(axum::http::header::CACHE_CONTROL, axum::http::HeaderValue::from_static("no-cache, max-age=2592000"));
+        return res;
+    }
+    // Forward to business logic
+    let result = service.images_list_public(&cache, account_id).await;
+    match result {
+        Ok(response) => {
+            let mut res = response.into_response();
+            if let Some(stored_etag) = cache.get(cache_key.as_ref()).await
+                && let Ok(etag) = axum::http::HeaderValue::from_str(&stored_etag)
+            {
+                res.headers_mut().insert(axum::http::header::ETAG, etag);
+            }
+            res.headers_mut().insert(axum::http::header::CACHE_CONTROL, axum::http::HeaderValue::from_static("no-cache, max-age=2592000"));
+            res
+        }
+        Err(e) => (
+            axum::http::StatusCode::INTERNAL_SERVER_ERROR,
+            format!("Internal error: {e}"),
+        )
+            .into_response(),
+    }
+}
+
+pub async fn images_get_image_handler<S, C>(
+    axum::extract::State(service): axum::extract::State<S>,
+    axum::extract::State(cache): axum::extract::State<C>,
+    if_none_match: Option<axum_extra::TypedHeader<axum_extra::headers::IfNoneMatch>>,
+    Path((account_id, image_id)): Path<(uuid::Uuid, String)>,
+) -> impl axum::response::IntoResponse
+where
+    S: Server + Send + Sync + 'static,
+    S::Claims: Send + Sync + Clone + 'static,
+    C: EtagCache + Clone + Send + Sync + 'static,
+{
+    // Check If-None-Match against the cache
+    let cache_key = format!("img:detail:pub:{account_id}:{image_id}");
+    if let (Some(stored_etag), Some(axum_extra::TypedHeader(inm))) =
+        (cache.get(cache_key.as_ref()).await, if_none_match)
+        && let Ok(etag) = stored_etag.parse::<axum_extra::headers::ETag>()
+        && !inm.precondition_passes(&etag)
+    {
+        let mut res = axum::http::StatusCode::NOT_MODIFIED.into_response();
+        res.headers_mut().insert(axum::http::header::CACHE_CONTROL, axum::http::HeaderValue::from_static("public, max-age=60"));
+        return res;
+    }
+    // Forward to business logic
+    let result = service.images_get_image(&cache, account_id, image_id).await;
+    match result {
+        Ok(response) => {
+            let mut res = response.into_response();
+            if let Some(stored_etag) = cache.get(cache_key.as_ref()).await
+                && let Ok(etag) = axum::http::HeaderValue::from_str(&stored_etag)
+            {
+                res.headers_mut().insert(axum::http::header::ETAG, etag);
+            }
+            res.headers_mut().insert(axum::http::header::CACHE_CONTROL, axum::http::HeaderValue::from_static("public, max-age=60"));
+            res
+        }
+        Err(e) => (
+            axum::http::StatusCode::INTERNAL_SERVER_ERROR,
+            format!("Internal error: {e}"),
+        )
+            .into_response(),
+    }
+}
+
 pub async fn articles_get_article_handler<S, C>(
     axum::extract::State(service): axum::extract::State<S>,
     axum::extract::State(cache): axum::extract::State<C>,
     if_none_match: Option<axum_extra::TypedHeader<axum_extra::headers::IfNoneMatch>>,
+    Extension(claims): Extension<S::Claims>,
     Path(id): Path<String>,
 ) -> impl axum::response::IntoResponse
 where
     S: Server + Send + Sync + 'static,
+    S::Claims: Send + Sync + Clone + 'static,
     C: EtagCache + Clone + Send + Sync + 'static,
 {
     // Check If-None-Match against the cache
-    let cache_key = "article-list";
-    if let (Some(stored_etag), Some(axum_extra::TypedHeader(inm))) = (cache.get(cache_key.as_ref()), if_none_match) {
-        // If the client's ETag matches, respond 304 immediately
-        if stored_etag == format!("{:?}", inm).trim_matches('"') {
-            let mut res = axum::http::StatusCode::NOT_MODIFIED.into_response();
-            res.headers_mut().insert(axum::http::header::CACHE_CONTROL, axum::http::HeaderValue::from_static("public, max-age=3600"));
-            return res;
-        }
+    let cache_key = format!("article-list:{id}");
+    if let (Some(stored_etag), Some(axum_extra::TypedHeader(inm))) =
+        (cache.get(cache_key.as_ref()).await, if_none_match)
+        && let Ok(etag) = stored_etag.parse::<axum_extra::headers::ETag>()
+        && !inm.precondition_passes(&etag)
+    {
+        let mut res = axum::http::StatusCode::NOT_MODIFIED.into_response();
+        res.headers_mut().insert(axum::http::header::CACHE_CONTROL, axum::http::HeaderValue::from_static("public, max-age=3600"));
+        return res;
     }
     // Forward to business logic
-    let result = service.articles_get_article(&cache, id).await;
+    let result = service.articles_get_article(claims, &cache, id).await;
     match result {
         Ok(response) => {
             let mut res = response.into_response();
-            if let Some(stored_etag) = cache.get(cache_key.as_ref()) {
-                res.headers_mut().insert(
-                    axum::http::header::ETAG,
-                    axum::http::HeaderValue::from_str(&stored_etag).unwrap(),
-                );
+            if let Some(stored_etag) = cache.get(cache_key.as_ref()).await
+                && let Ok(etag) = axum::http::HeaderValue::from_str(&stored_etag)
+            {
+                res.headers_mut().insert(axum::http::header::ETAG, etag);
             }
             res.headers_mut().insert(axum::http::header::CACHE_CONTROL, axum::http::HeaderValue::from_static("public, max-age=3600"));
             res
@@ -413,13 +565,18 @@ where
     let public = Router::new()
         .route("/events/{accountId}", get(events_accounts_events_handler::<S>))
         .route("/pets", get(pets_list_handler::<S>))
-        .route("/items", get(items_list_handler::<S>))
+        .route("/items", get(items_list_handler::<S, C>))
         .route("/items/{id}", get(items_get_item_handler::<S>))
         .route("/items", post(items_create_item_handler::<S>))
         .route("/items", put(items_update_item_handler::<S>))
-        .route("/articles", get(articles_get_article_handler::<S, C>))
+        .route("/accounts/{accountId}/images", get(images_list_public_handler::<S, C>))
+        .route("/accounts/{accountId}/images/{imageId}", get(images_get_image_handler::<S, C>))
         .route("/consuming", post(consuming_upload_handler::<S>))
         ;
     router = router.merge(public);
+    let protected = Router::new()
+        .route("/articles", get(articles_get_article_handler::<S, C>))
+        ;
+    router = router.merge(middleware(protected));
     router.with_state(service)
 }

package/example/output-rust/src/main.rs

@@ -7,8 +7,9 @@ use axum::response::IntoResponse;
 use axum::response::sse::{Event, KeepAlive, Sse};
 use generated::server::{
     ArticlesGetArticleResponse, ConsumingConsumeAndDeleteResponse, ConsumingUploadResponse,
-    EtagCache, EventsAccountsEventsResponse, ItemsCreateItemResponse, ItemsGetItemResponse,
-    ItemsListResponse, ItemsUpdateItemResponse, PetsListResponse, Server,
+    EtagCache, EventsAccountsEventsResponse, ImagesGetImageResponse, ImagesListPublicResponse,
+    ItemsCreateItemResponse, ItemsGetItemResponse, ItemsListResponse, ItemsUpdateItemResponse,
+    PetsListResponse, Server,
 };
 use std::collections::HashMap;
 use std::convert::Infallible;
@@ -20,11 +21,12 @@ use tokio_stream::{wrappers::IntervalStream, StreamExt as _};
 #[derive(Clone, Default)]
 struct InMemoryCache(Arc<Mutex<HashMap<String, String>>>);
 
+#[async_trait]
 impl EtagCache for InMemoryCache {
-    fn get(&self, key: &str) -> Option<String> {
+    async fn get(&self, key: &str) -> Option<String> {
         self.0.lock().unwrap().get(key).cloned()
     }
-    fn set(&self, key: &str, etag: &str) {
+    async fn set(&self, key: &str, etag: &str) {
         self.0.lock().unwrap().insert(key.to_owned(), etag.to_owned());
     }
 }
@@ -67,7 +69,11 @@ impl Server for AppState {
         ])))
     }
 
-    async fn items_list(&self) -> eyre::Result<ItemsListResponse> {
+    async fn items_list<C: EtagCache + Send + Sync>(
+        &self,
+        cache: &C,
+    ) -> eyre::Result<ItemsListResponse> {
+        cache.set("article-list", "\"items-etag\"").await;
         Ok(ItemsListResponse::Ok(Json(vec![generated::types::Item {
             name: "list-item".to_string(),
             value: 123,
@@ -102,13 +108,55 @@ impl Server for AppState {
         })))
     }
 
+    async fn images_list_public<C: EtagCache + Send + Sync>(
+        &self,
+        cache: &C,
+        account_id: uuid::Uuid,
+    ) -> eyre::Result<ImagesListPublicResponse> {
+        cache
+            .set(
+                &format!("img:list:pub:{}", account_id),
+                "\"images-list-etag\"",
+            )
+            .await;
+        Ok(ImagesListPublicResponse::Ok(Json(vec![
+            generated::types::Item {
+                name: "public-image-1".to_string(),
+                value: 200,
+            },
+            generated::types::Item {
+                name: "public-image-2".to_string(),
+                value: 201,
+            },
+        ])))
+    }
+
+    async fn images_get_image<C: EtagCache + Send + Sync>(
+        &self,
+        cache: &C,
+        account_id: uuid::Uuid,
+        image_id: String,
+    ) -> eyre::Result<ImagesGetImageResponse> {
+        cache
+            .set(
+                &format!("img:detail:pub:{}:{}", account_id, image_id),
+                "\"image-detail-etag\"",
+            )
+            .await;
+        Ok(ImagesGetImageResponse::Ok(Json(generated::types::Item {
+            name: format!("image-{}", image_id),
+            value: 300,
+        })))
+    }
+
     async fn articles_get_article<C: EtagCache + Send + Sync>(
         &self,
+        _claims: Self::Claims,
         cache: &C,
         id: String,
     ) -> eyre::Result<ArticlesGetArticleResponse> {
         let etag = format!("\"article-etag-{}\"", id);
-        cache.set(&format!("articles_get_article:{}", id), &etag);
+        cache.set(&format!("article-list:{}", id), &etag).await;
         Ok(ArticlesGetArticleResponse::Ok(Json(
             generated::types::Article {
                 id,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typespec-rust-emitter",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "description": "TypeSpec emitter that generates idiomatic Rust types and structs",
   "keywords": [
     "typespec",

package/scripts/update-golden.js

@@ -1,36 +1,36 @@
-import { readFileSync, writeFileSync } from 'node:fs';
-import { resolve } from 'node:path';
-import { emit } from '../dist/test/test-host.js';
+import { readFileSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { emit } from "../dist/test/test-host.js";
 
 async function main() {
   const feature = process.argv[2];
   if (!feature) {
-    console.error('Usage: node scripts/update-golden.js <feature>');
+    console.error("Usage: node scripts/update-golden.js <feature>");
     process.exit(1);
   }
 
   const specPath = resolve(process.cwd(), `test/golden/${feature}/spec.tsp`);
-  const spec = readFileSync(specPath, 'utf8');
-  
+  const spec = readFileSync(specPath, "utf8");
+
   console.log(`Emitting spec for ${feature}...`);
   const out = await emit(spec);
 
-  if (out['types.rs']) {
+  if (out["types.rs"]) {
     const p = resolve(process.cwd(), `test/golden/${feature}/types.rs`);
-    writeFileSync(p, out['types.rs']);
+    writeFileSync(p, out["types.rs"]);
     console.log(`Updated types.rs`);
   }
-  
-  if (out['server.rs']) {
+
+  if (out["server.rs"]) {
     const p = resolve(process.cwd(), `test/golden/${feature}/server.rs`);
-    writeFileSync(p, out['server.rs']);
+    writeFileSync(p, out["server.rs"]);
     console.log(`Updated server.rs`);
   }
 
   console.log(`Golden files updated for: ${feature}`);
 }
 
-main().catch(err => {
+main().catch((err) => {
   console.error(err);
   process.exit(1);
 });

package/src/generator/etag_router.ts

@@ -1,3 +1,5 @@
+import type { ParameterInfo } from "../models/types.js";
+
 /**
  * generateEtagCacheTrait
  *
@@ -7,109 +9,105 @@
 export function generateEtagCacheTrait(): string {
   return `/// Pluggable ETag cache backend.
 /// Implement this for Redis, Memcached, in-memory HashMap, or any store.
+#[async_trait]
 pub trait EtagCache {
     /// Return the stored ETag string for \`key\`, or \`None\` if not cached.
-    fn get(&self, key: &str) -> Option<String>;
+    async fn get(&self, key: &str) -> Option<String>;
     /// Store \`etag\` under \`key\`.
-    fn set(&self, key: &str, etag: &str);
+    async fn set(&self, key: &str, etag: &str);
 }
 `;
 }
 
+function rustStringLiteral(value: string): string {
+  return `"${value
+    .replace(/\\/g, "\\\\")
+    .replace(/"/g, '\\"')
+    .replace(/\n/g, "\\n")
+    .replace(/\r/g, "\\r")
+    .replace(/\t/g, "\\t")}"`;
+}
+
+function buildCacheKeyExpression(opts: {
+  handlerFnName: string;
+  etagKey?: string;
+  pathParams: ParameterInfo[];
+}): string {
+  const { handlerFnName, etagKey, pathParams } = opts;
+  const pathSuffix = pathParams.map((p) => `{${p.rustName}}`).join(":");
+  const paramNames = new Map<string, string>();
+  for (const param of pathParams) {
+    paramNames.set(param.name, param.rustName);
+    paramNames.set(param.rustName, param.rustName);
+  }
+
+  let template = etagKey ?? handlerFnName;
+  template = template.replace(/\{([^}]+)\}/g, (match, name: string) => {
+    const rustName = paramNames.get(name);
+    return rustName ? `{${rustName}}` : match;
+  });
+
+  const hasExplicitPathParam = pathParams.some(
+    (param) =>
+      template.includes(`{${param.name}}`) ||
+      template.includes(`{${param.rustName}}`),
+  );
+  if (pathSuffix && !hasExplicitPathParam) {
+    template = `${template}:${pathSuffix}`;
+  }
+
+  if (!template.includes("{")) {
+    return rustStringLiteral(template);
+  }
+  return `format!(${rustStringLiteral(template)})`;
+}
+
 /**
  * generateEtagHandler
  *
  * Returns the Rust source for a single ETag-aware axum handler.
  *
  * @param handlerFnName  snake_case name, e.g. "articles_get_article"
- * @param cacheKey       format string for the cache key, e.g. "articles_get_article:{id}"
- * @param pathParams     list of { rustName, rustType } for Path extractor
+ * @param pathParams     route path parameters used for cache key scoping
+ * @param extractorLines axum extractors needed by the operation
  * @param serverArgsStr  comma-separated args forwarded to the trait method
  * @param responseName   PascalCase name of the response enum, e.g. "ArticlesGetArticleResponse"
  */
 export function generateEtagHandler(opts: {
   handlerFnName: string;
-  cacheKey: string;
-  pathParams: { rustName: string; rustType: string }[];
+  pathParams: ParameterInfo[];
+  extractorLines: string[];
   serverArgsStr: string;
   responseName: string;
   etagKey?: string;
   cacheControl?: string;
+  serviceBinding?: string;
 }): string {
   const {
     handlerFnName,
-    cacheKey,
     pathParams,
+    extractorLines,
     serverArgsStr,
     etagKey,
     cacheControl,
+    serviceBinding = "service",
   } = opts;
 
-  // Build Path extractor
-  let pathExtractor = "";
-  if (pathParams.length === 1) {
-    pathExtractor = `    Path(${pathParams[0].rustName}): Path<${pathParams[0].rustType}>,\n`;
-  } else if (pathParams.length > 1) {
-    const names = pathParams.map((p) => p.rustName).join(", ");
-    const types = pathParams.map((p) => p.rustType).join(", ");
-    pathExtractor = `    Path((${names})): Path<(${types})>,\n`;
-  }
-
-  const effectiveCacheKey = etagKey ? `"${etagKey}"` : `format!("${cacheKey}")`;
-
-  let responseLogic = `    match result {
-        Ok(response) => {
-            let res = response.into_response();
-`;
-
-  const hasHeaders = !!cacheControl; // Currently only cacheControl adds headers here, but etag check also does.
-  // Wait, the etag check logic is different.
-  
-  if (cacheControl) {
-    responseLogic = `    match result {
-        Ok(response) => {
-            let mut res = response.into_response();
-            res.headers_mut().insert(
-                axum::http::header::CACHE_CONTROL,
-                axum::http::HeaderValue::from_static("${cacheControl}"),
-            );
-`;
-  }
-
-  // We should also potentially add the ETag header if we have one in cache
-  // But wait, the ETag value in cache is only valid if the response is successful and matches the cached version.
-  // Usually, the business logic would set the ETag in the cache.
-
-  responseLogic += `            if let Some(stored_etag) = cache.get(cache_key.as_ref()) {
-                let mut res = res; // Ensure it's mutable if we need to add etag
-                let mut res = if res.headers().get(axum::http::header::ETAG).is_none() {
-                    let mut res = res;
-                    res.headers_mut().insert(
-                        axum::http::header::ETAG,
-                        axum::http::HeaderValue::from_str(&stored_etag).unwrap(),
-                    );
-                    res
-                } else {
-                    res
-                };
-                res
-            } else {
-                res
-            }
-        }
-`;
-
-  // Actually, let's keep it simpler for now to avoid complexity in the template.
-  // I'll just fix the let_and_return for the common case.
+  const effectiveCacheKey = buildCacheKeyExpression({
+    handlerFnName,
+    etagKey,
+    pathParams,
+  });
+  const operationExtractors =
+    extractorLines.length > 0 ? `${extractorLines.join("\n")}\n` : "";
 
   const finalResponseLogic = `    match result {
         Ok(response) => {
             let mut res = response.into_response();
-            if let Some(stored_etag) = cache.get(cache_key.as_ref()) {
-                res.headers_mut().insert(
-                    axum::http::header::ETAG,
-                    axum::http::HeaderValue::from_str(&stored_etag).unwrap(),
-                );
+            if let Some(stored_etag) = cache.get(cache_key.as_ref()).await
+                && let Ok(etag) = axum::http::HeaderValue::from_str(&stored_etag)
+            {
+                res.headers_mut().insert(axum::http::header::ETAG, etag);
             }
             ${cacheControl ? `res.headers_mut().insert(axum::http::header::CACHE_CONTROL, axum::http::HeaderValue::from_static("${cacheControl}"));` : ""}
             res
@@ -122,26 +120,28 @@ export function generateEtagHandler(opts: {
     }`;
 
   return `pub async fn ${handlerFnName}_handler<S, C>(
-    axum::extract::State(service): axum::extract::State<S>,
+    axum::extract::State(${serviceBinding}): axum::extract::State<S>,
     axum::extract::State(cache): axum::extract::State<C>,
     if_none_match: Option<axum_extra::TypedHeader<axum_extra::headers::IfNoneMatch>>,
-${pathExtractor}) -> impl axum::response::IntoResponse
+${operationExtractors}) -> impl axum::response::IntoResponse
 where
     S: Server + Send + Sync + 'static,
+    S::Claims: Send + Sync + Clone + 'static,
     C: EtagCache + Clone + Send + Sync + 'static,
 {
     // Check If-None-Match against the cache
     let cache_key = ${effectiveCacheKey};
-    if let (Some(stored_etag), Some(axum_extra::TypedHeader(inm))) = (cache.get(cache_key.as_ref()), if_none_match) {
-        // If the client's ETag matches, respond 304 immediately
-        if stored_etag == format!("{:?}", inm).trim_matches('"') {
-            let mut res = axum::http::StatusCode::NOT_MODIFIED.into_response();
-            ${cacheControl ? `res.headers_mut().insert(axum::http::header::CACHE_CONTROL, axum::http::HeaderValue::from_static("${cacheControl}"));` : ""}
-            return res;
-        }
+    if let (Some(stored_etag), Some(axum_extra::TypedHeader(inm))) =
+        (cache.get(cache_key.as_ref()).await, if_none_match)
+        && let Ok(etag) = stored_etag.parse::<axum_extra::headers::ETag>()
+        && !inm.precondition_passes(&etag)
+    {
+        let mut res = axum::http::StatusCode::NOT_MODIFIED.into_response();
+        ${cacheControl ? `res.headers_mut().insert(axum::http::header::CACHE_CONTROL, axum::http::HeaderValue::from_static("${cacheControl}"));` : ""}
+        return res;
     }
     // Forward to business logic
-    let result = service.${handlerFnName}(&cache, ${serverArgsStr}).await;
+    let result = ${serviceBinding}.${handlerFnName}(${serverArgsStr}).await;
 ${finalResponseLogic}
 }`;
 }