typespec-rust-emitter 0.13.0 → 0.14.0

package/src/generator/router.ts

@@ -117,15 +117,18 @@ export function generateRouter(
       const serverArgsStr = serverArgs.join(", ");
 
       if (hasEtagCache(program, op)) {
-        const cacheKey = `${handlerFnName}:${pathParams.map((p) => `{${p.rustName}}`).join(":")}`;
+        const cachedServerArgs = isProtected
+          ? [serverArgs[0], "&cache", ...serverArgs.slice(1)]
+          : ["&cache", ...serverArgs];
         const code = generateEtagHandler({
           handlerFnName,
-          cacheKey,
           pathParams,
-          serverArgsStr,
+          extractorLines,
+          serverArgsStr: cachedServerArgs.join(", "),
           responseName: `${nsName}${toPascalCase(opInfo.name)}Response`,
           etagKey: opInfo.etagKey,
           cacheControl: opInfo.cacheControl,
+          serviceBinding,
         });
         handlers.push(code);
         const routePath = `"${opInfo.path}"`;
@@ -140,7 +143,7 @@ export function generateRouter(
 
       const serverCall = `service.${traitFnName}(${serverArgsStr}).await`;
 
-      let responseHandling = opInfo.cacheControl
+      const responseHandling = opInfo.cacheControl
         ? `match result {
         Ok(response) => {
             let mut res = response.into_response();

package/src/generator/server_trait.ts

@@ -29,7 +29,11 @@ use eyre::Result;
 
 `);
 
-  if (namespaceGroups.some((g) => g.operations.some((o) => hasEtagCache(program, o)))) {
+  if (
+    namespaceGroups.some((g) =>
+      g.operations.some((o) => hasEtagCache(program, o)),
+    )
+  ) {
     parts.push(generateEtagCacheTrait());
     parts.push("\n");
   }

package/src/parser/operations.ts

@@ -128,7 +128,9 @@ export function emitOperationInfo(
   const opName = op.name.replace(/[^a-zA-Z0-9_]/g, "_");
   const etagVal = program.stateMap(etagCacheKey).get(op);
   const etagKey = typeof etagVal === "string" ? etagVal : undefined;
-  const cacheControl = program.stateMap(cacheControlKey).get(op) as string | undefined;
+  const cacheControl = program.stateMap(cacheControlKey).get(op) as
+    | string
+    | undefined;
 
   return {
     name: opName,
@@ -144,7 +146,10 @@ export function emitOperationInfo(
   };
 }
 
-export function getEtagKey(program: Program, operation: Operation): string | undefined {
+export function getEtagKey(
+  program: Program,
+  operation: Operation,
+): string | undefined {
   const val = program.stateMap(etagCacheKey).get(operation);
   return typeof val === "string" ? val : undefined;
 }
@@ -153,6 +158,9 @@ export function hasEtagCache(program: Program, operation: Operation): boolean {
   return program.stateMap(etagCacheKey).has(operation);
 }
 
-export function getCacheControl(program: Program, operation: Operation): string | undefined {
+export function getCacheControl(
+  program: Program,
+  operation: Operation,
+): string | undefined {
   return program.stateMap(cacheControlKey).get(operation) as string | undefined;
 }

package/test/etag_cache.test.ts

@@ -28,17 +28,29 @@ describe("@etagCache decorator", () => {
     const server = results["server.rs"];
     strictEqual(server.includes("pub trait EtagCache"), true);
     strictEqual(
-      server.includes("fn get(&self, key: &str) -> Option<String>"),
+      server.includes("async fn get(&self, key: &str) -> Option<String>"),
+      true,
+    );
+    strictEqual(
+      server.includes("async fn set(&self, key: &str, etag: &str)"),
       true,
     );
-    strictEqual(server.includes("fn set(&self, key: &str, etag: &str)"), true);
   });
 
   it("generates cache-aware handler with 304 short-circuit", async () => {
     const results = await emit(ETAG_SPEC);
     const server = results["server.rs"];
     strictEqual(server.includes("axum::http::StatusCode::NOT_MODIFIED"), true);
-    strictEqual(server.includes("cache.get(cache_key.as_ref())"), true);
+    strictEqual(server.includes("cache.get(cache_key.as_ref()).await"), true);
+    strictEqual(
+      server.includes("stored_etag.parse::<axum_extra::headers::ETag>()"),
+      true,
+    );
+    strictEqual(server.includes("!inm.precondition_passes(&etag)"), true);
+    strictEqual(
+      server.includes("HeaderValue::from_str(&stored_etag).unwrap()"),
+      false,
+    );
   });
 
   it("supports custom etagKey and @cacheControl", async () => {
@@ -58,10 +70,87 @@ describe("@etagCache decorator", () => {
     const results = await emit(spec);
     const server = results["server.rs"];
     strictEqual(server.includes('let cache_key = "my-key";'), true);
-    strictEqual(server.includes('axum::http::header::CACHE_CONTROL'), true);
+    strictEqual(server.includes("axum::http::header::CACHE_CONTROL"), true);
     strictEqual(server.includes('"public"'), true);
   });
 
+  it("interpolates path parameters in custom etag keys", async () => {
+    const spec = `
+      import "@typespec/http";
+      import "typespec-rust-emitter";
+      using TypeSpec.Http;
+
+      @route("/accounts/{accountId}/images")
+      namespace Images {
+        @etagCache("img:list:pub:{accountId}")
+        @get
+        op listPublic(@path accountId: string): { @statusCode statusCode: 200; };
+      }
+    `;
+    const results = await emit(spec);
+    const server = results["server.rs"];
+    strictEqual(
+      server.includes('let cache_key = format!("img:list:pub:{account_id}");'),
+      true,
+    );
+  });
+
+  it("appends path parameters to static etag keys", async () => {
+    const spec = `
+      import "@typespec/http";
+      import "typespec-rust-emitter";
+      using TypeSpec.Http;
+
+      @route("/accounts/{accountId}/images")
+      namespace Images {
+        @etagCache("img:list:pub")
+        @get
+        op listPublic(@path accountId: string): { @statusCode statusCode: 200; };
+      }
+    `;
+    const results = await emit(spec);
+    const server = results["server.rs"];
+    strictEqual(
+      server.includes('let cache_key = format!("img:list:pub:{account_id}");'),
+      true,
+    );
+  });
+
+  it("orders cache after claims when combined with @useAuth", async () => {
+    const spec = `
+      import "@typespec/http";
+      import "typespec-rust-emitter";
+      using TypeSpec.Http;
+
+      model Article { id: string; title: string; }
+
+      @route("/articles")
+      namespace Articles {
+        @etagCache("article-list")
+        @useAuth(BearerAuth)
+        @get
+        op getArticle(@path id: string): {
+          @statusCode statusCode: 200;
+          @body body: Article;
+        };
+      }
+    `;
+    const results = await emit(spec);
+    const server = results["server.rs"];
+    strictEqual(
+      server.includes(
+        "async fn articles_get_article<C: EtagCache + Send + Sync>(\n        &self, claims: Self::Claims, cache: &C, id: String",
+      ),
+      true,
+    );
+    strictEqual(
+      server.includes(
+        "let result = service.articles_get_article(claims, &cache, id).await;",
+      ),
+      true,
+    );
+  });
+
   it("matches golden file", async () => {
     const results = await emit(ETAG_SPEC);
     compareWithGolden(results, "etag_cache", "server.rs");

package/test/golden/etag_cache/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);
 }
 
 
@@ -59,28 +60,29 @@ pub async fn articles_get_article_handler<S, C>(
 ) -> 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!("articles_get_article:{id}");
-    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();
-            
-            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();
+        
+        return res;
     }
     // Forward to business logic
     let result = service.articles_get_article(&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