typespec-rust-emitter 0.12.0 → 0.13.1

package/test/etag_cache.test.ts

@@ -0,0 +1,104 @@
+import { strictEqual } from "node:assert";
+import { describe, it } from "node:test";
+import { emit, compareWithGolden } from "./test-host.js";
+
+const ETAG_SPEC = `
+  import "@typespec/http";
+  import "typespec-rust-emitter";
+  using TypeSpec.Http;
+
+  model Article { id: string; title: string; }
+
+  @route("/articles")
+  namespace Articles {
+    @etagCache
+    @get
+    op getArticle(@path id: string): {
+      @statusCode statusCode: 200;
+      @body body: Article;
+    } | {
+      @statusCode statusCode: 304;
+    };
+  }
+`;
+
+describe("@etagCache decorator", () => {
+  it("generates EtagCache trait in server.rs", async () => {
+    const results = await emit(ETAG_SPEC);
+    const server = results["server.rs"];
+    strictEqual(server.includes("pub trait EtagCache"), true);
+    strictEqual(
+      server.includes("fn get(&self, key: &str) -> Option<String>"),
+      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);
+  });
+
+  it("supports custom etagKey and @cacheControl", async () => {
+    const spec = `
+      import "@typespec/http";
+      import "typespec-rust-emitter";
+      using TypeSpec.Http;
+
+      @route("/test")
+      namespace Test {
+        @etagCache("my-key")
+        @cacheControl("public")
+        @get
+        op run(): { @statusCode statusCode: 200; };
+      }
+    `;
+    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('"public"'), 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

@@ -0,0 +1,110 @@
+#![allow(unused)]
+
+use super::types::*;
+use async_trait::async_trait;
+use axum::extract::Path;
+use axum::Extension;
+use axum::http::StatusCode;
+use axum::response::IntoResponse;
+use axum::Json;
+use eyre::Result;
+
+
+/// Pluggable ETag cache backend.
+/// Implement this for Redis, Memcached, in-memory HashMap, or any store.
+pub trait EtagCache {
+    /// Return the stored ETag string for `key`, or `None` if not cached.
+    fn get(&self, key: &str) -> Option<String>;
+    /// Store `etag` under `key`.
+    fn set(&self, key: &str, etag: &str);
+}
+
+
+
+#[async_trait]
+pub trait Server: Send + Sync {
+    type Claims: Send + Sync + 'static;
+
+
+    async fn articles_get_article<C: EtagCache + Send + Sync>(
+        &self, cache: &C, id: String
+    ) -> Result<ArticlesGetArticleResponse>;
+}
+#[allow(clippy::type_complexity)]
+pub enum ArticlesGetArticleResponse {
+    Ok(Json<Article>),
+    NotModified,
+}
+
+impl IntoResponse for ArticlesGetArticleResponse {
+    fn into_response(self) -> axum::response::Response {
+        match self {
+
+            ArticlesGetArticleResponse::Ok(body) => (StatusCode::OK, body).into_response(),
+            ArticlesGetArticleResponse::NotModified => StatusCode::NOT_MODIFIED.into_response(),
+        }
+    }
+}
+
+use axum::extract::{Query, Multipart};
+use axum::routing::{get};
+use axum::Router;
+
+
+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>>,
+    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 = 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;
+        }
+    }
+    // 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(),
+                );
+            }
+            
+            res
+        }
+        Err(e) => (
+            axum::http::StatusCode::INTERNAL_SERVER_ERROR,
+            format!("Internal error: {e}"),
+        )
+            .into_response(),
+    }
+}
+
+pub fn create_router<S, C, M>(service: S, cache: C, middleware: M) -> Router
+where
+    S: Server + Clone + Send + Sync + 'static,
+    S::Claims: Send + Sync + Clone + 'static,
+    C: EtagCache + Clone + Send + Sync + 'static + axum::extract::FromRef<S>,
+    M: FnOnce(Router<S>) -> Router<S> + Clone + Send + Sync + 'static,
+{
+    let mut router = Router::new().with_state(cache);
+    let public = Router::new()
+        .route("/articles", get(articles_get_article_handler::<S, C>))
+        ;
+    router = router.merge(public);
+    router.with_state(service)
+}

package/test/golden/etag_cache/spec.tsp

@@ -0,0 +1,20 @@
+import "@typespec/http";
+import "typespec-rust-emitter";
+using TypeSpec.Http;
+
+model Article {
+  id: string;
+  title: string;
+}
+
+@route("/articles")
+namespace Articles {
+  @etagCache
+  @get
+  op getArticle(@path id: string): {
+    @statusCode statusCode: 200;
+    @body body: Article;
+  } | {
+    @statusCode statusCode: 304;
+  };
+}

package/test/golden/etag_cache/types.rs

@@ -0,0 +1,13 @@
+#![allow(unused)]
+
+use std::str::FromStr;
+use axum::http::StatusCode;
+use axum::response::IntoResponse;
+use axum::Json;
+
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+pub struct Article {
+  pub id: String,
+  pub title: String,
+}
+

package/test/test-host.ts

@@ -1,6 +1,7 @@
 import { Diagnostic, resolvePath } from "@typespec/compiler";
 import { expectDiagnosticEmpty } from "@typespec/compiler/testing";
 import { createTester } from "@typespec/compiler/testing";
+import { readFileSync } from "node:fs";
 
 export const Tester = createTester(resolvePath(import.meta.dirname, "../.."), {
   libraries: [
@@ -23,3 +24,45 @@ export async function emit(code: string): Promise<Record<string, string>> {
   expectDiagnosticEmpty(diagnostics);
   return result;
 }
+
+/**
+ * compareWithGolden
+ *
+ * Reads an expected file from test/golden/<goldenDir>/<fileName>
+ * and asserts that the emitted output matches it exactly.
+ *
+ * @param emitted  - Record produced by emit() e.g. { "types.rs": "...", "server.rs": "..." }
+ * @param goldenDir - Subdirectory name inside test/golden/
+ * @param fileName  - File key to check, e.g. "server.rs"
+ */
+export function compareWithGolden(
+  emitted: Record<string, string>,
+  goldenDir: string,
+  fileName: string,
+): void {
+  const goldenPath = resolvePath(
+    import.meta.dirname,
+    "../../test",
+    "golden",
+    goldenDir,
+    fileName,
+  );
+  const expected = readFileSync(goldenPath, "utf8");
+  const actual = emitted[fileName];
+  if (actual === undefined) {
+    throw new Error(
+      `Emitter did not produce "${fileName}". Keys: ${Object.keys(emitted).join(", ")}`,
+    );
+  }
+  if (actual !== expected) {
+    // Show a useful diff-style message.
+    const expectedLines = expected.split("\n");
+    const actualLines = actual.split("\n");
+    const firstDiff = expectedLines.findIndex((l, i) => l !== actualLines[i]);
+    throw new Error(
+      `Golden mismatch in ${goldenDir}/${fileName} at line ${firstDiff + 1}.\n` +
+        `Expected: ${expectedLines[firstDiff]}\n` +
+        `Actual:   ${actualLines[firstDiff]}`,
+    );
+  }
+}