typespec-rust-emitter 0.10.6 → 0.11.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,
@@ -393,7 +440,28 @@ function getOperationResponses(
   anonymousEnums: Map<string, AnonymousStringLiteralUnion>,
 ): ResponseInfo[] {
   const responses: ResponseInfo[] = [];
-  const returnType = operation.returnType;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const returnType = operation.returnType as any;
+
+  // Check for Array return type first (use runtime check since TS doesn't narrow Array)
+  if (
+    returnType.kind !== "Union" &&
+    returnType.kind !== "Model" &&
+    returnType.valueType
+  ) {
+    // This is an Array type
+    const { type: rustType } = getRustTypeForProperty(
+      returnType.valueType,
+      program,
+      anonymousEnums,
+    );
+    responses.push({
+      statusCode: 200,
+      bodyType: rustType,
+      bodyDescription: "",
+    });
+    return responses;
+  }
 
   if (returnType.kind === "Union") {
     const union = returnType as Union;
@@ -418,6 +486,7 @@ function getOperationResponses(
       });
       return responses;
     }
+    let foundStatusCode = false;
     for (const [propName, prop] of model.properties) {
       if (propName === "body") {
         const { type: rustType } = getRustTypeForProperty(
@@ -430,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;
@@ -679,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}>;`,
           );
         }
       }
@@ -806,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;
@@ -822,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) {
@@ -850,7 +942,10 @@ function generateRouter(
       if (hasQueryParams && queryParams.length > 0) {
         const queryTypeName = `${toPascalCase(handlerFnName)}Query`;
         const queryFields = queryParams
-          .map((p) => `    pub ${p.rustName}: ${p.rustType}`)
+          .map(
+            (p) =>
+              `    #[serde(rename = "${p.name}")]\n    pub ${p.rustName}: ${p.rustType}`,
+          )
           .join(",\n");
         queryTypeStructs.push(
           `#[derive(Debug, Clone, serde::Deserialize)]\npub struct ${queryTypeName} {\n${queryFields}\n}`,
@@ -877,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};
@@ -898,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);
+  });
 });

package/example/lib/learning/models.tsp

@@ -1,234 +0,0 @@
-import "typespec-rust-emitter";
-import "@typespec/events";
-
-using TypeSpec.Events;
-
-namespace Mtlkms.Learning.Models {
-  // ── COMMON ─────────────────────────────────────────────────────────────────
-
-  @error
-  model ApiError {
-    @doc("Machine-readable error code.")
-    code: string;
-
-    @doc("Human-readable message.")
-    message: string;
-  }
-
-  model NotFoundError extends ApiError {
-    code: "NOT_FOUND";
-  }
-  model ValidationError extends ApiError {
-    code: "VALIDATION_ERROR";
-  }
-  model ConflictError extends ApiError {
-    code: "CONFLICT";
-  }
-
-  // ── SCALARS & ENUMS ───────────────────────────────────────────────────────
-
-  @format("uuid")
-  scalar Uuid extends string;
-
-  @pattern("^#[0-9A-Fa-f]{6}$")
-  scalar HexColor extends string;
-
-  @rustDerive("sqlx::Type")
-  @rustAttr("sqlx(type_name = \"study_status\")")
-  enum StudyStatus {
-    Starting: "Starting",
-    Paused: "Paused",
-    Stopped: "Stopped",
-  }
-
-  enum ChartGranularity {
-    Day: "day",
-    Week: "week",
-    Month: "month",
-    Year: "year",
-  }
-
-  // ── AGGREGATION MIXIN ──────────────────────────────────────────────────────
-
-  @doc("Duration statistics calculated in real-time from timelogs. Unit: seconds.")
-  model DurationStats {
-    durationTotal: int64;
-    durationDay: int64;
-    durationWeek: int64;
-    durationMonth: int64;
-  }
-
-  model CalendarHeatmapItem {
-    date: string;
-    duration: int64;
-  }
-
-  // ── MODELS: GROUP ─────────────────────────────────────────────────────────
-
-  model Group {
-    id: int64;
-    accountId: Uuid;
-    createdAt: utcDateTime;
-    deletedAt: utcDateTime | null;
-
-    @maxLength(255)
-    name: string;
-
-    @maxLength(44)
-    icon: string;
-
-    colorText: HexColor;
-    colorBg: HexColor;
-  }
-
-  @rustDerive("sqlx::FromRow")
-  model GroupStatistics {
-    ...Group;
-    subjectCount: int64;
-    status: StudyStatus;
-    ...DurationStats;
-  }
-
-  model CreateGroupBody {
-    @maxLength(255)
-    name: string;
-
-    @maxLength(44)
-    icon: string;
-
-    colorText: HexColor;
-    colorBg: HexColor;
-  }
-
-  model UpdateGroupBody {
-    @maxLength(255)
-    name?: string;
-
-    @maxLength(44)
-    icon?: string;
-
-    colorText?: HexColor;
-    colorBg?: HexColor;
-  }
-
-  // ── MODELS: SUBJECT ───────────────────────────────────────────────────────
-
-  model Subject {
-    id: int64;
-    accountId: Uuid;
-    groupId: int64;
-    createdAt: utcDateTime;
-    deletedAt: utcDateTime | null;
-
-    @maxLength(255)
-    name: string;
-
-    @maxLength(44)
-    icon: string;
-
-    colorText: HexColor;
-    colorBg: HexColor;
-  }
-
-  model SubjectStatistics {
-    ...Subject;
-    status: StudyStatus;
-    ...DurationStats;
-  }
-
-  model CreateSubjectBody {
-    @maxLength(255)
-    name: string;
-
-    @maxLength(44)
-    icon: string;
-
-    colorText: HexColor;
-    colorBg: HexColor;
-  }
-
-  model UpdateSubjectBody {
-    @maxLength(255)
-    name?: string;
-
-    @maxLength(44)
-    icon?: string;
-
-    colorText?: HexColor;
-    colorBg?: HexColor;
-  }
-
-  // ── MODELS: SESSION ───────────────────────────────────────────────────────
-
-  model Log {
-    id: int64;
-    accountId: Uuid;
-    subjectId: int64;
-    startedAt: utcDateTime;
-    stoppedAt: utcDateTime | null;
-    logContent: string | null;
-    status: StudyStatus;
-  }
-
-  model Timelog {
-    id: int64;
-    accountId: Uuid;
-    logId: int64;
-    subjectId: int64;
-    startedAt: utcDateTime;
-    stoppedAt: utcDateTime | null;
-    durationInSeconds: int64;
-  }
-
-  model LogWithTimelogs {
-    ...Log;
-    timelogs: Timelog[];
-  }
-
-  @doc("Event payload for learning data changes.")
-  model SessionEvent {
-    eventType: "session" | "session_pause" | "session_resume" | "session_stop";
-    session: LogWithTimelogs;
-  }
-
-  @doc("Event payload for group CRUD.")
-  model GroupEvent {
-    eventType: "group_created" | "group_updated" | "group_deleted";
-    group: Group;
-  }
-
-  @doc("Event payload for subject CRUD.")
-  model SubjectEvent {
-    eventType:
-      | "subject_created"
-      | "subject_updated"
-      | "subject_deleted"
-      | "subject_moved";
-    subject: Subject;
-  }
-
-  @doc("Union of all learning events for SSE.")
-  @events
-  union LearningEvents {
-    sessionEvent: SessionEvent,
-    groupEvent: GroupEvent,
-    subjectEvent: SubjectEvent,
-  }
-
-  @doc("Response after start/resume — returns the log and the newly opened timelog segment.")
-  model SessionOpenedResponse {
-    log: Log;
-    timelog: Timelog;
-  }
-
-  @doc("Response after pause/stop — returns the log and the newly closed timelog segment.")
-  model SessionClosedResponse {
-    log: Log;
-    timelog: Timelog;
-  }
-
-  @doc("Optional payload for start or stop operations — contains a note for the session.")
-  model SessionNoteBody {
-    logContent?: string;
-  }
-}