typespec-rust-emitter 0.10.7 → 0.12.0

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,
@@ -316,7 +363,11 @@ function getOperationParameters(
       for (const key of Object.keys(decorators)) {
         const decorator = decorators[key];
         const name = getDecoratorName(decorator);
-        if (name === "body" || name === "bodyRoot") {
+        if (
+          name === "body" ||
+          name === "bodyRoot" ||
+          name === "multipartBody"
+        ) {
           isBody = true;
           break;
         }
@@ -379,7 +430,7 @@ function getOperationBody(operation: Operation): ModelProperty | undefined {
     for (const key of Object.keys(decorators)) {
       const decorator = decorators[key];
       const name = getDecoratorName(decorator);
-      if (name === "body" || name === "bodyRoot") {
+      if (name === "body" || name === "bodyRoot" || name === "multipartBody") {
         return prop;
       }
     }
@@ -387,6 +438,23 @@ function getOperationBody(operation: Operation): ModelProperty | undefined {
   return undefined;
 }
 
+function hasMultipartBody(operation: Operation): boolean {
+  for (const [_propName, prop] of operation.parameters.properties) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const decorators = (prop as any).decorators;
+    if (!decorators) continue;
+
+    for (const key of Object.keys(decorators)) {
+      const decorator = decorators[key];
+      const name = getDecoratorName(decorator);
+      if (name === "multipartBody") {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
 function getOperationResponses(
   program: Program,
   operation: Operation,
@@ -439,6 +507,7 @@ function getOperationResponses(
       });
       return responses;
     }
+    let foundStatusCode = false;
     for (const [propName, prop] of model.properties) {
       if (propName === "body") {
         const { type: rustType } = getRustTypeForProperty(
@@ -451,8 +520,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;
@@ -691,34 +779,39 @@ pub trait Server: Send + Sync {
 
       // Add body parameter
       if (opInfo.body) {
-        const bodyType = getRustTypeForProperty(
-          opInfo.body.type,
-          program,
-          anonymousEnums,
-        );
-        paramParts.push(`body: ${bodyType.type}`);
+        if (hasMultipartBody(op)) {
+          paramParts.push(`body: Multipart`);
+        } else {
+          const bodyType = getRustTypeForProperty(
+            opInfo.body.type,
+            program,
+            anonymousEnums,
+          );
+          paramParts.push(`body: ${bodyType.type}`);
+        }
       }
 
       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 +920,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;
@@ -835,14 +929,17 @@ function generateRouter(
       );
       const hasQueryParams = queryParams.length > 0;
       const hasBody = !!opInfo.body;
+      const isMultipartBody = hasMultipartBody(op);
 
       // Build extractor lines and server method call arguments
       // IMPORTANT: axum requires specific extractor order:
-      // State -> Extension -> Path -> Query -> Json -> Body
+      // State -> Extension -> Path -> Query -> Json/Multipart -> Body
       const extractorLines: string[] = [];
       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) {
@@ -885,15 +982,20 @@ function generateRouter(
         }
       }
 
-      // Json body comes last
+      // Body comes last (Json or Multipart based on decorator)
       if (hasBody && opInfo.body) {
-        const bodyType = getRustTypeForProperty(
-          opInfo.body.type,
-          program,
-          anonymousEnums,
-        );
-        extractorLines.push(`    Json(payload): Json<${bodyType.type}>,`);
-        serverArgs.push(`payload`);
+        if (isMultipartBody) {
+          extractorLines.push(`    multipart: axum::extract::Multipart,`);
+          serverArgs.push(`multipart`);
+        } else {
+          const bodyType = getRustTypeForProperty(
+            opInfo.body.type,
+            program,
+            anonymousEnums,
+          );
+          extractorLines.push(`    Json(payload): Json<${bodyType.type}>,`);
+          serverArgs.push(`payload`);
+        }
       }
 
       // Build server method call
@@ -901,12 +1003,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 +1049,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) {
@@ -939,7 +1071,7 @@ where
   const routerBody = buildRouterBody(publicRoutes, protectedRoutes);
 
   const parts: string[] = [];
-  parts.push(`use axum::extract::Query;
+  parts.push(`use axum::extract::{Query, Multipart};
 use axum::routing::{${methodImports}};
 use axum::Router;
 

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,146 @@ 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);
+  });
+
+  it("emits multipartBody with Multipart extractor", async () => {
+    const results = await emit(`
+      import "@typespec/http";
+      using TypeSpec.Http;
+
+      @route("/upload")
+      namespace Upload {
+        @post
+        op uploadFile(
+          @path accountId: string,
+          @multipartBody body: {
+            image: HttpPart<File>,
+          },
+        ): {
+          @statusCode statusCode: 201;
+          @body body: string;
+        };
+      }
+    `);
+    const server = results["server.rs"];
+    strictEqual(server.includes("multipart: axum::extract::Multipart,"), true);
+    strictEqual(server.includes("body: Multipart"), true);
+  });
 });