typespec-rust-emitter 0.13.1 → 0.14.1

package/src/generator/router.ts

@@ -117,13 +117,13 @@ 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,
+          queryParams,
           extractorLines,
           serverArgsStr: cachedServerArgs.join(", "),
           responseName: `${nsName}${toPascalCase(opInfo.name)}Response`,
@@ -144,7 +144,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,117 @@ 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("does not use mut binding as the call receiver with @rustMut", async () => {
+    const spec = `
+      import "@typespec/http";
+      import "typespec-rust-emitter";
+      using TypeSpec.Http;
+
+      @route("/accounts/{accountId}/groups")
+      namespace Groups {
+        @etagCache("groups:logs:{accountId}:last:{lastId}:limit:{limit}")
+        @rustMut
+        @get
+        op listLogs(
+          @path accountId: string,
+          @query lastId: string | null,
+          @query limit: int32,
+        ): { @statusCode statusCode: 200; };
+      }
+    `;
+    const results = await emit(spec);
+    const server = results["server.rs"];
+    strictEqual(
+      server.includes(
+        "axum::extract::State(mut service): axum::extract::State<S>",
+      ),
+      true,
+    );
+    strictEqual(server.includes("let result = mut service."), false);
+    strictEqual(
+      server.includes(
+        "let result = service.groups_list_logs(&cache, account_id, params.last_id, params.limit).await;",
+      ),
+      true,
+    );
+  });
+
+  it("interpolates query parameters in custom etag keys", async () => {
+    const spec = `
+      import "@typespec/http";
+      import "typespec-rust-emitter";
+      using TypeSpec.Http;
+
+      @route("/accounts/{accountId}/groups")
+      namespace Groups {
+        @etagCache("groups:list:{accountId}:tz:{userTimezone}:last:{lastId}:limit:{limit}")
+        @get
+        op list(
+          @path accountId: string,
+          @query userTimezone: string,
+          @query lastId: string | null,
+          @query limit: int32,
+        ): { @statusCode statusCode: 200; };
+      }
+    `;
+    const results = await emit(spec);
+    const server = results["server.rs"];
+    strictEqual(
+      server.includes(
+        'let cache_key = format!("groups:list:{account_id}:tz:{}:last:{:?}:limit:{}", params.user_timezone, params.last_id, params.limit);',
+      ),
+      true,
+    );
+    strictEqual(server.includes("{userTimezone}"), false);
+    strictEqual(server.includes("{lastId}"), false);
+  });
+
   it("orders cache after claims when combined with @useAuth", async () => {
     const spec = `
       import "@typespec/http";

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);
 }
 
 
@@ -64,24 +65,24 @@ where
 {
     // 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