typespec-rust-emitter 0.10.7 → 0.11.0

package/example/main.tsp

@@ -1,6 +1,7 @@
 import "@typespec/http";
 import "@typespec/sse";
 import "@typespec/events";
+import "typespec-rust-emitter";
 
 using TypeSpec.Http;
 using TypeSpec.SSE;
@@ -31,3 +32,40 @@ namespace Pets {
     @body body: string[];
   };
 }
+
+model Item {
+  name: string;
+  value: int32;
+}
+
+@route("/items")
+namespace Items {
+  @get
+  op getItem(@query id: string): {
+    @statusCode status: 200;
+    @body body: Item;
+  };
+
+  @rustMut
+  @post
+  op createItem(@body item: Item): {
+    @statusCode status: 201;
+    @body body: Item;
+  };
+
+  @rustMut
+  @put
+  op updateItem(@query id: string, @body item: Item): {
+    @statusCode status: 200;
+    @body body: Item;
+  };
+}
+
+@route("/consuming")
+namespace Consuming {
+  @rustOwn
+  @delete
+  op consumeAndDelete(@query id: string): {
+    @statusCode status: 204;
+  };
+}

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

@@ -16,6 +16,10 @@ 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_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 consuming_consume_and_delete(self, id: String) -> Result<ConsumingConsumeAndDeleteResponse>;
 }
 #[allow(clippy::type_complexity)]
 pub enum EventsAccountsEventsResponse {
@@ -45,8 +49,64 @@ impl IntoResponse for PetsListResponse {
     }
 }
 
+#[allow(clippy::type_complexity)]
+pub enum ItemsGetItemResponse {
+    Ok(Json<Item>),
+}
+
+impl IntoResponse for ItemsGetItemResponse {
+    fn into_response(self) -> axum::response::Response {
+        match self {
+
+            ItemsGetItemResponse::Ok(body) => (StatusCode::OK, body).into_response(),
+        }
+    }
+}
+
+#[allow(clippy::type_complexity)]
+pub enum ItemsCreateItemResponse {
+    Ok(Json<Item>),
+}
+
+impl IntoResponse for ItemsCreateItemResponse {
+    fn into_response(self) -> axum::response::Response {
+        match self {
+
+            ItemsCreateItemResponse::Ok(body) => (StatusCode::OK, body).into_response(),
+        }
+    }
+}
+
+#[allow(clippy::type_complexity)]
+pub enum ItemsUpdateItemResponse {
+    Ok(Json<Item>),
+}
+
+impl IntoResponse for ItemsUpdateItemResponse {
+    fn into_response(self) -> axum::response::Response {
+        match self {
+
+            ItemsUpdateItemResponse::Ok(body) => (StatusCode::OK, body).into_response(),
+        }
+    }
+}
+
+#[allow(clippy::type_complexity)]
+pub enum ConsumingConsumeAndDeleteResponse {
+    Ok,
+}
+
+impl IntoResponse for ConsumingConsumeAndDeleteResponse {
+    fn into_response(self) -> axum::response::Response {
+        match self {
+
+            ConsumingConsumeAndDeleteResponse::Ok => StatusCode::OK.into_response(),
+        }
+    }
+}
+
 use axum::extract::Query;
-use axum::routing::{get};
+use axum::routing::{delete, get, post, put};
 use axum::Router;
 
 
@@ -58,6 +118,24 @@ pub struct PetsListQuery {
     pub second_query: String
 }
 
+#[derive(Debug, Clone, serde::Deserialize)]
+pub struct ItemsGetItemQuery {
+    #[serde(rename = "id")]
+    pub id: String
+}
+
+#[derive(Debug, Clone, serde::Deserialize)]
+pub struct ItemsUpdateItemQuery {
+    #[serde(rename = "id")]
+    pub id: String
+}
+
+#[derive(Debug, Clone, serde::Deserialize)]
+pub struct ConsumingConsumeAndDeleteQuery {
+    #[serde(rename = "id")]
+    pub id: String
+}
+
 
 
 pub async fn events_accounts_events_handler<S>(
@@ -65,7 +143,7 @@ pub async fn events_accounts_events_handler<S>(
     Path(account_id): Path<String>,
 ) -> impl axum::response::IntoResponse
 where
-    S: Server + Clone + Send + Sync + 'static,
+    S: Server+ Clone + Send + Sync + 'static,
     S::Claims: Send + Sync + Clone + 'static,
 {
     let result = service.events_accounts_events(account_id).await;
@@ -84,7 +162,7 @@ pub async fn pets_list_handler<S>(
     Query(params): Query<PetsListQuery>,
 ) -> impl axum::response::IntoResponse
 where
-    S: Server + Clone + Send + Sync + 'static,
+    S: Server+ Clone + Send + Sync + 'static,
     S::Claims: Send + Sync + Clone + 'static,
 {
     let result = service.pets_list(params.first_query, params.second_query).await;
@@ -98,6 +176,85 @@ where
     }
 }
 
+pub async fn items_get_item_handler<S>(
+    axum::extract::State(service): axum::extract::State<S>,
+    Query(params): Query<ItemsGetItemQuery>,
+) -> impl axum::response::IntoResponse
+where
+    S: Server+ Clone + Send + Sync + 'static,
+    S::Claims: Send + Sync + Clone + 'static,
+{
+    let result = service.items_get_item(params.id).await;
+    match result {
+        Ok(response) => response.into_response(),
+        Err(e) => (
+            axum::http::StatusCode::INTERNAL_SERVER_ERROR,
+            format!("Internal error: {e}"),
+        )
+            .into_response(),
+    }
+}
+
+pub async fn items_create_item_handler<S>(
+    axum::extract::State(mut service): axum::extract::State<S>,
+    Json(payload): Json<Item>,
+) -> impl axum::response::IntoResponse
+where
+    S: Server+ Clone + Send + Sync + 'static,
+    S::Claims: Send + Sync + Clone + 'static,
+{
+    let result = service.items_create_item(payload).await;
+    match result {
+        Ok(response) => response.into_response(),
+        Err(e) => (
+            axum::http::StatusCode::INTERNAL_SERVER_ERROR,
+            format!("Internal error: {e}"),
+        )
+            .into_response(),
+    }
+}
+
+pub async fn items_update_item_handler<S>(
+    axum::extract::State(mut service): axum::extract::State<S>,
+    Query(params): Query<ItemsUpdateItemQuery>,
+    Json(payload): Json<Item>,
+) -> impl axum::response::IntoResponse
+where
+    S: Server+ Clone + Send + Sync + 'static,
+    S::Claims: Send + Sync + Clone + 'static,
+{
+    let result = service.items_update_item(params.id, payload).await;
+    match result {
+        Ok(response) => response.into_response(),
+        Err(e) => (
+            axum::http::StatusCode::INTERNAL_SERVER_ERROR,
+            format!("Internal error: {e}"),
+        )
+            .into_response(),
+    }
+}
+
+// NOTE: consuming_consume_and_delete takes self and cannot be used with the router pattern.
+// It consumes the service, so you need to implement your own handler pattern.
+pub async fn consuming_consume_and_delete_handler<S>(
+    axum::extract::State(service): axum::extract::State<S>,
+    Query(params): Query<ConsumingConsumeAndDeleteQuery>,
+) -> impl axum::response::IntoResponse
+where
+    S: Server + Send + Sync + 'static,
+    S::Claims: Send + Sync + Clone + 'static,
+{
+    let result = service.consuming_consume_and_delete(params.id).await;
+    match result {
+        Ok(response) => response.into_response(),
+        Err(e) => (
+            axum::http::StatusCode::INTERNAL_SERVER_ERROR,
+            format!("Internal error: {e}"),
+        )
+            .into_response(),
+    }
+}
+
 pub fn create_router<S, M>(service: S, middleware: M) -> Router
 where
     S: Server + Clone + Send + Sync + 'static,
@@ -108,6 +265,9 @@ 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_get_item_handler::<S>))
+        .route("/items", post(items_create_item_handler::<S>))
+        .route("/items", put(items_update_item_handler::<S>))
         ;
     router = router.merge(public);
     router.with_state(service)

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

@@ -10,6 +10,12 @@ pub struct MyEventData {
   pub message: String,
 }
 
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+pub struct Item {
+  pub name: String,
+  pub value: i32,
+}
+
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 #[serde(untagged)]
 pub enum MyEvent {

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

@@ -3,14 +3,13 @@ mod generated;
 use async_trait::async_trait;
 use axum::response::IntoResponse;
 use axum::response::sse::{Event, KeepAlive, Sse};
-use generated::server::{EventsAccountsEventsResponse, Server};
+use axum::Json;
+use generated::server::{EventsAccountsEventsResponse, ItemsCreateItemResponse, ItemsGetItemResponse, ItemsUpdateItemResponse, ConsumingConsumeAndDeleteResponse, PetsListResponse, Server};
 use std::convert::Infallible;
 use std::time::Duration;
 use tokio::time::interval;
 use tokio_stream::{StreamExt as _, wrappers::IntervalStream};
 
-use crate::generated::server::PetsListResponse;
-
 #[derive(Clone)]
 struct AppState;
 
@@ -24,7 +23,7 @@ impl Server for AppState {
     ) -> eyre::Result<EventsAccountsEventsResponse> {
         let stream = IntervalStream::new(interval(Duration::from_millis(100)))
             .map(|_| Ok::<_, Infallible>(Event::default().data("hi!")))
-            .take(3); // emit 3 events
+            .take(3);
 
         let stream = Sse::new(stream).keep_alive(KeepAlive::default());
         Ok(EventsAccountsEventsResponse::Ok(stream.into_response()))
@@ -35,7 +34,42 @@ impl Server for AppState {
         _first_query: String,
         _second_query: String,
     ) -> eyre::Result<PetsListResponse> {
-        todo!()
+        Ok(PetsListResponse::Ok(Json(vec!["pet1".to_string(), "pet2".to_string()])))
+    }
+
+    async fn items_get_item(&self, _id: String) -> eyre::Result<ItemsGetItemResponse> {
+        Ok(ItemsGetItemResponse::Ok(Json(generated::types::Item {
+            name: "test".to_string(),
+            value: 42,
+        })))
+    }
+
+    async fn items_create_item(
+        &mut self,
+        _body: generated::types::Item,
+    ) -> eyre::Result<ItemsCreateItemResponse> {
+        Ok(ItemsCreateItemResponse::Ok(Json(generated::types::Item {
+            name: "created".to_string(),
+            value: 0,
+        })))
+    }
+
+    async fn items_update_item(
+        &mut self,
+        _id: String,
+        _body: generated::types::Item,
+    ) -> eyre::Result<ItemsUpdateItemResponse> {
+        Ok(ItemsUpdateItemResponse::Ok(Json(generated::types::Item {
+            name: "updated".to_string(),
+            value: 1,
+        })))
+    }
+
+    async fn consuming_consume_and_delete(
+        self,
+        _id: String,
+    ) -> eyre::Result<ConsumingConsumeAndDeleteResponse> {
+        Ok(ConsumingConsumeAndDeleteResponse::Ok)
     }
 }
 

package/package.json

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

package/src/emitter.ts

@@ -39,6 +39,9 @@ interface RustAttrInfo {
 const rustDeriveKey = Symbol("rustDerive");
 const rustAttrKey = Symbol("rustAttr");
 const rustImplKey = Symbol("rustImpl");
+const rustSelfReceiverKey = Symbol("rustSelfReceiver");
+
+type SelfReceiver = "&self" | "&mut self" | "self";
 
 interface RustImplInfo {
   impl: string;
@@ -168,6 +171,42 @@ export function $rustImpl(
   }
 }
 
+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";
+  }
+}
+
 type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD";
 
 interface OperationInfo {
@@ -298,6 +337,14 @@ function hasAuthDecorator(operation: Operation): boolean {
   return false;
 }
 
+function getSelfReceiver(operation: Operation): SelfReceiver {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const receiver = (operation as any)[rustSelfReceiverKey] as
+    | SelfReceiver
+    | undefined;
+  return receiver ?? "&self";
+}
+
 function getOperationParameters(
   program: Program,
   operation: Operation,
@@ -439,6 +486,7 @@ function getOperationResponses(
       });
       return responses;
     }
+    let foundStatusCode = false;
     for (const [propName, prop] of model.properties) {
       if (propName === "body") {
         const { type: rustType } = getRustTypeForProperty(
@@ -451,8 +499,27 @@ function getOperationResponses(
           bodyType: rustType,
           bodyDescription: getDoc(program, prop),
         });
+      } else if (propName === "statusCode") {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const typeAny = prop.type as any;
+        if (typeAny.value !== undefined) {
+          const statusCode = typeAny.value as number;
+          responses.push({
+            statusCode,
+            bodyType: undefined,
+            bodyDescription: undefined,
+          });
+          foundStatusCode = true;
+        }
       }
     }
+    if (!foundStatusCode && responses.length === 0) {
+      responses.push({
+        statusCode: 200,
+        bodyType: undefined,
+        bodyDescription: undefined,
+      });
+    }
   }
 
   return responses;
@@ -700,25 +767,26 @@ pub trait Server: Send + Sync {
       }
 
       const paramsStr = paramParts.join(", ");
+      const selfReceiver = getSelfReceiver(op);
 
       if (isProtected) {
         if (paramsStr) {
           parts.push(
-            `    async fn ${fnName}(&self, claims: Self::Claims, ${paramsStr}) -> Result<${responseName}>;`,
+            `    async fn ${fnName}(${selfReceiver}, claims: Self::Claims, ${paramsStr}) -> Result<${responseName}>;`,
           );
         } else {
           parts.push(
-            `    async fn ${fnName}(&self, claims: Self::Claims) -> Result<${responseName}>;`,
+            `    async fn ${fnName}(${selfReceiver}, claims: Self::Claims) -> Result<${responseName}>;`,
           );
         }
       } else {
         if (paramsStr) {
           parts.push(
-            `    async fn ${fnName}(&self, ${paramsStr}) -> Result<${responseName}>;`,
+            `    async fn ${fnName}(${selfReceiver}, ${paramsStr}) -> Result<${responseName}>;`,
           );
         } else {
           parts.push(
-            `    async fn ${fnName}(&self) -> Result<${responseName}>;`,
+            `    async fn ${fnName}(${selfReceiver}) -> Result<${responseName}>;`,
           );
         }
       }
@@ -827,6 +895,7 @@ function generateRouter(
       const handlerFnName = toRustIdent(`${nsName}_${opInfo.name}`);
       const traitFnName = handlerFnName;
       const isProtected = hasAuthDecorator(op);
+      const selfReceiver = getSelfReceiver(op);
 
       const pathParams = opInfo.parameters.filter((p) => p.location === "path");
       const hasPathParams = pathParams.length > 0;
@@ -843,6 +912,8 @@ function generateRouter(
       const serverArgs: string[] = [];
 
       // State is always first (added in handler template)
+      const serviceBinding =
+        selfReceiver === "&mut self" ? "mut service" : "service";
 
       // Extension (claims) comes after State
       if (isProtected) {
@@ -901,12 +972,37 @@ function generateRouter(
       const serverCall = `service.${traitFnName}(${serverArgsStr}).await`;
 
       // All handlers use <S> generics, Claims is now an associated type
-      const handlerCode = `pub async fn ${handlerFnName}_handler<S>(
+      // For &mut self, we need Clone because service is extracted multiple times
+      // For self, we can't use Clone (would need Arc/Mutex or different pattern)
+      const needsClone = selfReceiver !== "self" ? "+ Clone" : "";
+      const handlerCode =
+        selfReceiver === "self"
+          ? `// NOTE: ${handlerFnName} takes self and cannot be used with the router pattern.
+// It consumes the service, so you need to implement your own handler pattern.
+pub async fn ${handlerFnName}_handler<S>(
     axum::extract::State(service): axum::extract::State<S>,
 ${extractorLines.join("\n")}
 ) -> impl axum::response::IntoResponse
 where
-    S: Server + Clone + Send + Sync + 'static,
+    S: Server + Send + Sync + 'static,
+    S::Claims: Send + Sync + Clone + 'static,
+{
+    let result = service.${traitFnName}(${serverArgsStr}).await;
+    match result {
+        Ok(response) => response.into_response(),
+        Err(e) => (
+            axum::http::StatusCode::INTERNAL_SERVER_ERROR,
+            format!("Internal error: {e}"),
+        )
+            .into_response(),
+    }
+}`
+          : `pub async fn ${handlerFnName}_handler<S>(
+    axum::extract::State(${serviceBinding}): axum::extract::State<S>,
+${extractorLines.join("\n")}
+) -> impl axum::response::IntoResponse
+where
+    S: Server${needsClone} + Send + Sync + 'static,
     S::Claims: Send + Sync + Clone + 'static,
 {
     let result = ${serverCall};
@@ -922,6 +1018,11 @@ where
 
       handlers.push(handlerCode);
 
+      // Don't add routes for self methods (they consume the service)
+      if (selfReceiver === "self") {
+        continue;
+      }
+
       const routePath = `"${opInfo.path}"`;
       let routeStmt = "";
       if (isProtected) {

package/src/index.ts

@@ -5,5 +5,7 @@ export {
   $rustAttr,
   $rustAttrs,
   $rustImpl,
+  $rustMut,
+  $rustOwn,
 } from "./emitter.js";
 export { $lib } from "./lib.js";

package/src/lib.tsp

@@ -7,3 +7,5 @@ extern dec rustDerives(target: Model | Enum, ...derives: valueof string[]);
 extern dec rustAttr(target: Model | Enum | ModelProperty, attr: valueof string);
 extern dec rustAttrs(target: Model | Enum | ModelProperty, ...attrs: valueof string[]);
 extern dec rustImpl(target: Model, impl: valueof string);
+extern dec rustMut(target: Operation);
+extern dec rustOwn(target: Operation);

package/test/hello.test.ts

@@ -1,6 +1,6 @@
 import { strictEqual } from "node:assert";
 import { describe, it } from "node:test";
-import { emit } from "./test-host.js";
+import { emit, emitWithDiagnostics } from "./test-host.js";
 
 describe("Rust emitter", () => {
   it("emits basic model", async () => {
@@ -443,4 +443,122 @@ describe("Rust emitter", () => {
       true,
     );
   });
+
+  it("uses &self by default in trait methods", async () => {
+    const results = await emit(`
+      import "@typespec/http";
+      import "typespec-rust-emitter";
+      using TypeSpec.Http;
+
+      @route("/test")
+      namespace Test {
+        @get
+        op getItem(): { @statusCode status: 200; @body body: string };
+      }
+    `);
+    const server = results["server.rs"];
+    strictEqual(server.includes("async fn test_get_item(&self)"), true);
+  });
+
+  it("uses &mut self with @rustMut decorator", async () => {
+    const results = await emit(`
+      import "@typespec/http";
+      import "typespec-rust-emitter";
+      using TypeSpec.Http;
+
+      @route("/test")
+      namespace Test {
+        @rustMut
+        @post
+        op createItem(@body name: string): { @statusCode status: 200; @body body: string };
+      }
+    `);
+    const server = results["server.rs"];
+    strictEqual(server.includes("test_create_item(&mut self,"), true);
+  });
+
+  it("uses self with @rustOwn decorator", async () => {
+    const results = await emit(`
+      import "@typespec/http";
+      import "typespec-rust-emitter";
+      using TypeSpec.Http;
+
+      @route("/test")
+      namespace Test {
+        @rustOwn
+        @delete
+        op deleteItem(): { @statusCode status: 200; @body body: string };
+      }
+    `);
+    const server = results["server.rs"];
+    strictEqual(server.includes("test_delete_item(self)"), true);
+  });
+
+  it("@rustMut works with protected routes", async () => {
+    const results = await emit(`
+      import "@typespec/http";
+      import "typespec-rust-emitter";
+      using TypeSpec.Http;
+
+      @route("/test")
+      namespace Test {
+        @rustMut
+        @post
+        op createItem(@body name: string, @header Authorization: string): { @statusCode status: 200; @body body: string };
+      }
+    `);
+    const server = results["server.rs"];
+    strictEqual(server.includes("test_create_item(&mut self,"), true);
+  });
+
+  it("@rustOwn works with protected routes", async () => {
+    const results = await emit(`
+      import "@typespec/http";
+      import "typespec-rust-emitter";
+      using TypeSpec.Http;
+
+      @route("/test")
+      namespace Test {
+        @rustOwn
+        @delete
+        op deleteItem(@query id: string): { @statusCode status: 200; @body body: string };
+      }
+    `);
+    const server = results["server.rs"];
+    strictEqual(server.includes("test_delete_item(self,"), true);
+  });
+
+  it("reports error when @rustMut is applied to non-operation", async () => {
+    const [, diagnostics] = await emitWithDiagnostics(`
+      import "@typespec/http";
+      import "typespec-rust-emitter";
+      using TypeSpec.Http;
+
+      @rustMut
+      model Test {
+        name: string;
+      }
+    `);
+    const hasError = diagnostics.some(
+      (d) => d.code === "decorator-wrong-target",
+    );
+    strictEqual(hasError, true);
+  });
+
+  it("reports error when @rustOwn is applied to non-operation", async () => {
+    const [, diagnostics] = await emitWithDiagnostics(`
+      import "@typespec/http";
+      import "typespec-rust-emitter";
+      using TypeSpec.Http;
+
+      @rustOwn
+      model Test {
+        name: string;
+      }
+    `);
+    const hasError = diagnostics.some(
+      (d) => d.code === "decorator-wrong-target",
+    );
+    strictEqual(hasError, true);
+  });
 });