typespec-rust-emitter 0.12.0 → 0.13.0

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

@@ -2,20 +2,43 @@ mod generated;
 
 use async_trait::async_trait;
 use axum::Json;
+use axum::extract::FromRef;
 use axum::response::IntoResponse;
 use axum::response::sse::{Event, KeepAlive, Sse};
 use generated::server::{
-    ConsumingConsumeAndDeleteResponse, ConsumingUploadResponse, EventsAccountsEventsResponse,
-    ItemsCreateItemResponse, ItemsGetItemResponse, ItemsUpdateItemResponse, PetsListResponse,
-    Server,
+    ArticlesGetArticleResponse, ConsumingConsumeAndDeleteResponse, ConsumingUploadResponse,
+    EtagCache, EventsAccountsEventsResponse, ItemsCreateItemResponse, ItemsGetItemResponse,
+    ItemsListResponse, ItemsUpdateItemResponse, PetsListResponse, Server,
 };
+use std::collections::HashMap;
 use std::convert::Infallible;
+use std::sync::{Arc, Mutex};
 use std::time::Duration;
 use tokio::time::interval;
-use tokio_stream::{StreamExt as _, wrappers::IntervalStream};
+use tokio_stream::{wrappers::IntervalStream, StreamExt as _};
+
+#[derive(Clone, Default)]
+struct InMemoryCache(Arc<Mutex<HashMap<String, String>>>);
+
+impl EtagCache for InMemoryCache {
+    fn get(&self, key: &str) -> Option<String> {
+        self.0.lock().unwrap().get(key).cloned()
+    }
+    fn set(&self, key: &str, etag: &str) {
+        self.0.lock().unwrap().insert(key.to_owned(), etag.to_owned());
+    }
+}
 
 #[derive(Clone)]
-struct AppState;
+struct AppState {
+    cache: InMemoryCache,
+}
+
+impl FromRef<AppState> for InMemoryCache {
+    fn from_ref(state: &AppState) -> Self {
+        state.cache.clone()
+    }
+}
 
 #[async_trait]
 impl Server for AppState {
@@ -44,6 +67,13 @@ impl Server for AppState {
         ])))
     }
 
+    async fn items_list(&self) -> eyre::Result<ItemsListResponse> {
+        Ok(ItemsListResponse::Ok(Json(vec![generated::types::Item {
+            name: "list-item".to_string(),
+            value: 123,
+        }])))
+    }
+
     async fn items_get_item(&self, _id: String) -> eyre::Result<ItemsGetItemResponse> {
         Ok(ItemsGetItemResponse::Ok(Json(generated::types::Item {
             name: "test".to_string(),
@@ -72,6 +102,21 @@ impl Server for AppState {
         })))
     }
 
+    async fn articles_get_article<C: EtagCache + Send + Sync>(
+        &self,
+        cache: &C,
+        id: String,
+    ) -> eyre::Result<ArticlesGetArticleResponse> {
+        let etag = format!("\"article-etag-{}\"", id);
+        cache.set(&format!("articles_get_article:{}", id), &etag);
+        Ok(ArticlesGetArticleResponse::Ok(Json(
+            generated::types::Article {
+                id,
+                title: "Example Article".to_string(),
+            },
+        )))
+    }
+
     async fn consuming_consume_and_delete(
         self,
         _id: String,
@@ -90,7 +135,10 @@ impl Server for AppState {
 
 #[tokio::main]
 async fn main() {
-    let app = generated::server::create_router(AppState, |r| r);
+    let state = AppState {
+        cache: InMemoryCache::default(),
+    };
+    let app = generated::server::create_router(state.clone(), state.cache.clone(), |r| r);
     let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
     println!("Server running on {}", listener.local_addr().unwrap());
     axum::serve(listener, app).await.unwrap();
@@ -105,26 +153,24 @@ mod tests {
 
     #[tokio::test]
     async fn test_sse_endpoint() {
-        // Wait! The generated route in `example/output-rust/src/generated/server.rs` uses `/events/{accountId}` literally!
-        // We might need to use `/events/{accountId}` in the request to match, or fix the emitter if it's broken.
-        // Let's use whatever route is in the generated code to test the SSE handler logic first.
-        let app = generated::server::create_router(AppState, |r| r);
+        let state = AppState {
+            cache: InMemoryCache::default(),
+        };
+        let app = generated::server::create_router(state.clone(), state.cache.clone(), |r| r);
 
         let req = Request::builder()
-            .uri("/events/123") // If the emitter generates {accountId}, axum won't match this if it requires `:accountId`.
-            // Wait, actually I should check if axum matches {accountId} or if it fails.
+            .uri("/events/123")
             .body(axum::body::Body::empty())
             .unwrap();
 
         let response = app.oneshot(req).await.unwrap();
 
-        // If axum doesn't match, we will get 404. Let's handle both.
         if response.status() == 404 {
             let req2 = Request::builder()
                 .uri("/events/{accountId}")
                 .body(axum::body::Body::empty())
                 .unwrap();
-            let app = generated::server::create_router(AppState, |r| r);
+            let app = generated::server::create_router(state.clone(), state.cache.clone(), |r| r);
             let response2 = app.oneshot(req2).await.unwrap();
             assert_eq!(response2.status(), 200);
             return;
@@ -136,7 +182,6 @@ mod tests {
             "text/event-stream"
         );
 
-        // Read body frames sequentially
         let mut body = response.into_body();
         let mut timestamps = Vec::new();
 
@@ -149,18 +194,6 @@ mod tests {
             }
         }
 
-        // We should have received 3 events
         assert_eq!(timestamps.len(), 3);
-
-        // Verify delay between events (approx 100ms)
-        for i in 1..timestamps.len() {
-            let diff = timestamps[i].duration_since(timestamps[i - 1]);
-            // Give it some slack for CI / slow execution, but ensure it's not instantaneous
-            assert!(
-                diff.as_millis() >= 80,
-                "Events were too fast! Diff: {}ms",
-                diff.as_millis()
-            );
-        }
     }
 }

package/justfile

@@ -1,7 +1,36 @@
 set dotenv-load := true
 
+# ─── Build & Test ────────────────────────────────────────────────────────────
+
+# Build TypeScript and run all Jest/node:test tests.
+test:
+    npm run build && npm test
+
+# Lint and format source.
+lint:
+    npm run lint && npm run format:check
+
+# ─── Rust Validation ─────────────────────────────────────────────────────────
+
+# Re-compile the example TypeSpec spec and validate the generated Rust code.
 check-rust:
     cd example && tsp compile . && cd output-rust && cargo check && cargo clippy
 
-publish:
-    npm run build && npm publish
+# ─── Combined ────────────────────────────────────────────────────────────────
+
+# Run everything: TypeScript tests + Rust check. Use this before a release.
+check-all: test check-rust
+    @echo "✓ All checks passed."
+
+# ─── Golden File Helpers ─────────────────────────────────────────────────────
+
+# Re-generate and overwrite the golden file for a given feature.
+# Usage: just update-golden etag_cache
+update-golden feature:
+    node scripts/update-golden.js {{feature}}
+
+# ─── Release ─────────────────────────────────────────────────────────────────
+
+# Publish to npm. Run check-all first.
+publish: check-all
+    npm publish

package/package.json

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

package/scripts/update-golden.js

@@ -0,0 +1,36 @@
+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>');
+    process.exit(1);
+  }
+
+  const specPath = resolve(process.cwd(), `test/golden/${feature}/spec.tsp`);
+  const spec = readFileSync(specPath, 'utf8');
+  
+  console.log(`Emitting spec for ${feature}...`);
+  const out = await emit(spec);
+
+  if (out['types.rs']) {
+    const p = resolve(process.cwd(), `test/golden/${feature}/types.rs`);
+    writeFileSync(p, out['types.rs']);
+    console.log(`Updated types.rs`);
+  }
+  
+  if (out['server.rs']) {
+    const p = resolve(process.cwd(), `test/golden/${feature}/server.rs`);
+    writeFileSync(p, out['server.rs']);
+    console.log(`Updated server.rs`);
+  }
+
+  console.log(`Golden files updated for: ${feature}`);
+}
+
+main().catch(err => {
+  console.error(err);
+  process.exit(1);
+});

package/src/decorators/cache_control.ts

@@ -0,0 +1,14 @@
+import { DecoratorContext, Operation } from "@typespec/compiler";
+import { cacheControlKey } from "../models/keys.js";
+
+/**
+ * @cacheControl decorator implementation.
+ * Stores the cache control value on the operation.
+ */
+export function $cacheControl(
+  context: DecoratorContext,
+  target: Operation,
+  value: string,
+) {
+  context.program.stateMap(cacheControlKey).set(target, value);
+}

package/src/decorators/etag_cache.ts

@@ -0,0 +1,14 @@
+import { DecoratorContext, Operation } from "@typespec/compiler";
+import { etagCacheKey } from "../models/keys.js";
+
+/**
+ * @etagCache decorator implementation.
+ * Stores the optional etagKey on the operation.
+ */
+export function $etagCache(
+  context: DecoratorContext,
+  target: Operation,
+  etagKey?: string,
+) {
+  context.program.stateMap(etagCacheKey).set(target, etagKey ?? true);
+}

package/src/decorators/index.ts

@@ -0,0 +1,6 @@
+export * from "./rust_derive.js";
+export * from "./rust_attr.js";
+export * from "./rust_impl.js";
+export * from "./rust_self.js";
+export * from "./etag_cache.js";
+export * from "./cache_control.js";

package/src/decorators/rust_attr.ts

@@ -0,0 +1,61 @@
+import {
+  DecoratorContext,
+  getNamespaceFullName,
+  Namespace,
+  Type,
+} from "@typespec/compiler";
+import { rustAttrKey } from "../models/keys.js";
+import { RustAttrInfo } from "../models/types.js";
+
+export function $rustAttr(
+  context: DecoratorContext,
+  target: Type,
+  attr: string,
+) {
+  if (
+    target.kind !== "Model" &&
+    target.kind !== "Enum" &&
+    target.kind !== "ModelProperty"
+  ) {
+    context.program.reportDiagnostic({
+      code: "rust-attr-invalid-target",
+      message: `@rustAttr can only be applied to models, enums, and model properties`,
+      severity: "error",
+      target: context.decoratorTarget,
+    });
+    return;
+  }
+
+  let ns: Namespace | undefined;
+  if (target.kind === "Model") {
+    ns = target.namespace;
+  } else if (target.kind === "Enum") {
+    ns = target.namespace;
+  } else if (target.kind === "ModelProperty") {
+    ns = target.model?.namespace;
+  }
+
+  const nsFullName = ns ? getNamespaceFullName(ns) : "";
+  if (!nsFullName.startsWith("TypeSpec")) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const info = (target as any)[rustAttrKey] as RustAttrInfo | undefined;
+    if (info) {
+      if (!info.attrs.includes(attr)) {
+        info.attrs.push(attr);
+      }
+    } else {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      (target as any)[rustAttrKey] = { attrs: [attr] };
+    }
+  }
+}
+
+export function $rustAttrs(
+  context: DecoratorContext,
+  target: Type,
+  ...attrs: string[]
+) {
+  for (const attr of attrs) {
+    $rustAttr(context, target, attr);
+  }
+}

package/src/decorators/rust_derive.ts

@@ -0,0 +1,55 @@
+import {
+  DecoratorContext,
+  getNamespaceFullName,
+  Type,
+} from "@typespec/compiler";
+import { rustDeriveKey } from "../models/keys.js";
+import { RustDeriveInfo } from "../models/types.js";
+
+export function $rustDerive(
+  context: DecoratorContext,
+  target: Type,
+  derive: string,
+) {
+  if (target.kind !== "Model" && target.kind !== "Enum") {
+    context.program.reportDiagnostic({
+      code: "rust-derive-invalid-target",
+      message: `@rustDerive can only be applied to models and enums`,
+      severity: "error",
+      target: context.decoratorTarget,
+    });
+    return;
+  }
+
+  const ns =
+    target.kind === "Model"
+      ? target.namespace
+        ? getNamespaceFullName(target.namespace)
+        : ""
+      : target.namespace
+        ? getNamespaceFullName(target.namespace)
+        : "";
+
+  if (!ns.startsWith("TypeSpec")) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const info = (target as any)[rustDeriveKey] as RustDeriveInfo | undefined;
+    if (info) {
+      if (!info.derives.includes(derive)) {
+        info.derives.push(derive);
+      }
+    } else {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      (target as any)[rustDeriveKey] = { derives: [derive] };
+    }
+  }
+}
+
+export function $rustDerives(
+  context: DecoratorContext,
+  target: Type,
+  ...derives: string[]
+) {
+  for (const derive of derives) {
+    $rustDerive(context, target, derive);
+  }
+}

package/src/decorators/rust_impl.ts

@@ -0,0 +1,29 @@
+import {
+  DecoratorContext,
+  getNamespaceFullName,
+  Type,
+} from "@typespec/compiler";
+import { rustImplKey } from "../models/keys.js";
+
+export function $rustImpl(
+  context: DecoratorContext,
+  target: Type,
+  impl: string,
+) {
+  if (target.kind !== "Model") {
+    context.program.reportDiagnostic({
+      code: "rust-impl-invalid-target",
+      message: `@rustImpl can only be applied to models`,
+      severity: "error",
+      target: context.decoratorTarget,
+    });
+    return;
+  }
+
+  const ns = target.namespace ? getNamespaceFullName(target.namespace) : "";
+
+  if (!ns.startsWith("TypeSpec")) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (target as any)[rustImplKey] = { impl: impl };
+  }
+}

package/src/decorators/rust_self.ts

@@ -0,0 +1,42 @@
+import {
+  DecoratorContext,
+  getNamespaceFullName,
+  Type,
+} from "@typespec/compiler";
+import { rustSelfReceiverKey } from "../models/keys.js";
+
+export function $rustMut(context: DecoratorContext, target: Type) {
+  if (target.kind !== "Operation") {
+    context.program.reportDiagnostic({
+      code: "rust-mut-invalid-target",
+      message: `@rustMut can only be applied to operations`,
+      severity: "error",
+      target: context.decoratorTarget,
+    });
+    return;
+  }
+
+  const ns = target.namespace ? getNamespaceFullName(target.namespace) : "";
+  if (!ns.startsWith("TypeSpec")) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (target as any)[rustSelfReceiverKey] = "&mut self";
+  }
+}
+
+export function $rustOwn(context: DecoratorContext, target: Type) {
+  if (target.kind !== "Operation") {
+    context.program.reportDiagnostic({
+      code: "rust-own-invalid-target",
+      message: `@rustOwn can only be applied to operations`,
+      severity: "error",
+      target: context.decoratorTarget,
+    });
+    return;
+  }
+
+  const ns = target.namespace ? getNamespaceFullName(target.namespace) : "";
+  if (!ns.startsWith("TypeSpec")) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (target as any)[rustSelfReceiverKey] = "self";
+  }
+}