typespec-rust-emitter 0.10.2 → 0.10.5

package/src/emitter.ts

@@ -194,6 +194,7 @@ interface ResponseInfo {
   statusCode: number;
   bodyType: string | undefined;
   bodyDescription: string | undefined;
+  isSse?: boolean;
 }
 
 function getDecoratorName(decorator: {
@@ -403,10 +404,21 @@ function getOperationResponses(
         statusCode,
         bodyType: bodyInfo.type,
         bodyDescription: bodyInfo.description,
+        isSse: bodyInfo.isSse,
       });
     }
   } else if (returnType.kind === "Model") {
     const model = returnType as Model;
+    if (model.name === "SSEStream") {
+      responses.push({
+        statusCode: 200,
+        bodyType:
+          "axum::response::sse::Sse<std::pin::Pin<Box<dyn futures::stream::Stream<Item = Result<axum::response::sse::Event, std::convert::Infallible>> + Send>>>",
+        bodyDescription: "Server-Sent Events stream",
+        isSse: true,
+      });
+      return responses;
+    }
     for (const [propName, prop] of model.properties) {
       if (propName === "body") {
         const { type: rustType } = getRustTypeForProperty(
@@ -446,9 +458,20 @@ function getBodyFromResponse(
   variant: { type: Type },
   program: Program,
   anonymousEnums: Map<string, AnonymousStringLiteralUnion>,
-): { type: string | undefined; description: string | undefined } {
+): {
+  type: string | undefined;
+  description: string | undefined;
+  isSse?: boolean;
+} {
   if (variant.type.kind === "Model") {
     const model = variant.type as Model;
+    if (model.name === "SSEStream") {
+      return {
+        type: "axum::response::sse::Sse<std::pin::Pin<Box<dyn futures::stream::Stream<Item = Result<axum::response::sse::Event, std::convert::Infallible>> + Send>>>",
+        description: "Server-Sent Events stream",
+        isSse: true,
+      };
+    }
     for (const [_propName, prop] of model.properties) {
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       const decorators = (prop as any).decorators;
@@ -639,6 +662,13 @@ pub trait Server: Send + Sync {
         }
       }
 
+      // Add query parameters
+      for (const param of opInfo.parameters) {
+        if (param.location === "query") {
+          paramParts.push(`${param.rustName}: ${param.rustType}`);
+        }
+      }
+
       // Add body parameter
       if (opInfo.body) {
         const bodyType = getRustTypeForProperty(
@@ -705,11 +735,14 @@ function generateResponseEnums(
         const variantName = getStatusVariantName(resp.statusCode);
         if (!resp.bodyType) {
           variants.push(`    ${variantName},`);
+        } else if (resp.isSse) {
+          variants.push(`    ${variantName}(${resp.bodyType}),`);
         } else {
           variants.push(`    ${variantName}(Json<${resp.bodyType}>),`);
         }
       }
-      parts.push(`pub enum ${responseName} {
+      parts.push(`#[allow(clippy::type_complexity)]
+pub enum ${responseName} {
 ${variants.join("\n")}
 }
 `);
@@ -725,6 +758,10 @@ ${variants.join("\n")}
           parts.push(
             `            ${responseName}::${variantName} => ${statusCodeStr}.into_response(),`,
           );
+        } else if (resp.isSse) {
+          parts.push(
+            `            ${responseName}::${variantName}(body) => body.into_response(),`,
+          );
         } else {
           parts.push(
             `            ${responseName}::${variantName}(body) => (${statusCodeStr}, body).into_response(),`,
@@ -747,6 +784,7 @@ function generateRouter(
   anonymousEnums: Map<string, AnonymousStringLiteralUnion>,
 ): string {
   const handlers: string[] = [];
+  const queryTypeStructs: string[] = [];
   const publicRoutes: string[] = [];
   const protectedRoutes: string[] = [];
   const usedMethods = new Set<string>();
@@ -772,6 +810,10 @@ function generateRouter(
 
       const pathParams = opInfo.parameters.filter((p) => p.location === "path");
       const hasPathParams = pathParams.length > 0;
+      const queryParams = opInfo.parameters.filter(
+        (p) => p.location === "query",
+      );
+      const hasQueryParams = queryParams.length > 0;
       const hasBody = !!opInfo.body;
 
       // Build extractor lines and server method call arguments
@@ -805,6 +847,21 @@ function generateRouter(
         }
       }
 
+      // Query params come after Path
+      if (hasQueryParams && queryParams.length > 0) {
+        const queryTypeName = `${toPascalCase(handlerFnName)}Query`;
+        const queryFields = queryParams
+          .map((p) => `    pub ${p.rustName}: ${p.rustType}`)
+          .join(",\n");
+        queryTypeStructs.push(
+          `#[derive(Debug, Clone, serde::Deserialize)]\npub struct ${queryTypeName} {\n${queryFields}\n}`,
+        );
+        extractorLines.push(`    Query(params): Query<${queryTypeName}>,`);
+        for (const param of queryParams) {
+          serverArgs.push(`params.${param.rustName}`);
+        }
+      }
+
       // Json body comes last
       if (hasBody && opInfo.body) {
         const bodyType = getRustTypeForProperty(
@@ -859,10 +916,15 @@ where
   const routerBody = buildRouterBody(publicRoutes, protectedRoutes);
 
   const parts: string[] = [];
-  parts.push(`use axum::routing::{${methodImports}};
+  parts.push(`use axum::extract::Query;
+use axum::routing::{${methodImports}};
 use axum::Router;
 
 `);
+  if (queryTypeStructs.length > 0) {
+    parts.push(queryTypeStructs.join("\n\n"));
+    parts.push("\n\n");
+  }
   parts.push(handlers.join("\n\n"));
   parts.push(`
 pub fn create_router<S, M>(service: S, middleware: M) -> Router
@@ -1026,7 +1088,9 @@ function getRustTypeForProperty(
         };
       }
       const values = variants.map((v) => (v.type as StringLiteral).value);
-      const enumName = `Enum_${values.slice(0, 2).join("_")}_${values.length}`;
+      const sanitized = values.map((v) => v.replace(/_/g, ""));
+      const firstTwo = sanitized.slice(0, 2).map(toPascalCase).join("");
+      const enumName = `Enum${firstTwo}${sanitized.length}`;
       if (!anonymousEnums.has(enumName)) {
         anonymousEnums.set(enumName, {
           enumName,
@@ -1179,12 +1243,12 @@ function emitStringLiteralUnion(union: Union): string {
   const variants = Array.from(union.variants.values());
 
   parts.push(
-    `#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default, serde::Serialize, serde::Deserialize)]\npub enum ${name} {`,
+    `#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default, serde::Serialize, serde::Deserialize)]\n#[allow(clippy::enum_variant_names)]\npub enum ${name} {`,
   );
 
   for (let i = 0; i < variants.length; i++) {
     const literalType = variants[i].type as StringLiteral;
-    const variantName = toRustVariantName(literalType.value);
+    const variantName = toPascalCase(literalType.value);
     const serdeValue = literalType.value;
     if (i === 0) {
       parts.push(`  #[default]`);
@@ -1515,11 +1579,11 @@ export async function $onEmit(
   for (const [enumName, anonEnum] of anonymousEnums) {
     const parts: string[] = [];
     parts.push(
-      `#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default, serde::Serialize, serde::Deserialize)]\npub enum ${enumName} {`,
+      `#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default, serde::Serialize, serde::Deserialize)]\n#[allow(clippy::enum_variant_names)]\npub enum ${enumName} {`,
     );
     for (let i = 0; i < anonEnum.variants.length; i++) {
       const literal = anonEnum.variants[i];
-      const variantName = toRustVariantName(literal.value);
+      const variantName = toPascalCase(literal.value);
       if (i === 0) {
         parts.push(`  #[default]`);
       }
@@ -1571,6 +1635,11 @@ export async function $onEmit(
     content: outputContent,
   });
 
+  await emitFile(context.program, {
+    path: resolvePath(context.emitterOutputDir, "mod.rs"),
+    content: "pub mod server;\npub mod types;\n",
+  });
+
   if (namespaceGroups.length > 0) {
     const serverTrait = generateServerTrait(
       context.program,

package/test/hello.test.ts

@@ -50,6 +50,17 @@ describe("Rust emitter", () => {
     strictEqual(output.includes("Pending,"), true);
   });
 
+  it("emits anonymous string enum without underscores", async () => {
+    const results = await emit(`
+      model Event {
+        eventType: "event_one" | "event_two" | "event_three",
+      }
+    `);
+    const output = results["types.rs"];
+    const badNameContainsUnderscore = output.includes("Enum_event_one_");
+    strictEqual(badNameContainsUnderscore, false);
+  });
+
   it("emits integer enum", async () => {
     const results = await emit(`
       enum Priority {
@@ -369,4 +380,72 @@ describe("Rust emitter", () => {
     const output = results["types.rs"];
     strictEqual(output.includes("impl IntoResponse for ApiError"), false);
   });
+
+  it("emits query parameters in handlers", async () => {
+    const results = await emit(`
+      import "@typespec/http";
+      using TypeSpec.Http;
+
+      model CalendarItem {
+        date: string;
+      }
+
+      @route("/calendar/{accountId}")
+      namespace Calendar {
+        @get
+        @tag("Calendar")
+        op getCalendar(
+          @path accountId: string,
+          @query year: int32,
+          @query month: int32,
+        ): {
+          @statusCode statusCode: 200;
+          @body body: CalendarItem[];
+        };
+      }
+    `);
+    const server = results["server.rs"];
+    strictEqual(server.includes("Query(params): Query"), true);
+    strictEqual(server.includes("pub year: i32"), true);
+    strictEqual(server.includes("pub month: i32"), true);
+    strictEqual(server.includes("params.year"), true);
+    strictEqual(server.includes("params.month"), true);
+  });
+  it("emits SSEStream properly", async () => {
+    const results = await emit(`
+      import "@typespec/http";
+      import "@typespec/sse";
+      import "@typespec/events";
+      using TypeSpec.Http;
+      using TypeSpec.SSE;
+
+      model TestEventData {
+        data: string;
+      }
+
+      @TypeSpec.Events.events
+      union TestEvent {
+        data: TestEventData
+      }
+
+      @route("/events")
+      namespace Events {
+        @get
+        op stream(): SSEStream<TestEvent>;
+      }
+    `);
+    const server = results["server.rs"];
+    strictEqual(
+      server.includes(
+        "axum::response::sse::Sse<std::pin::Pin<Box<dyn futures::stream::Stream<Item = Result<axum::response::sse::Event, std::convert::Infallible>> + Send>>>",
+      ),
+      true,
+    );
+    strictEqual(
+      server.includes(
+        "EventsStreamResponse::Ok(body) => body.into_response(),",
+      ),
+      true,
+    );
+  });
 });

package/test/test-host.ts

@@ -3,7 +3,12 @@ import { expectDiagnosticEmpty } from "@typespec/compiler/testing";
 import { createTester } from "@typespec/compiler/testing";
 
 export const Tester = createTester(resolvePath(import.meta.dirname, "../.."), {
-  libraries: ["typespec-rust-emitter"],
+  libraries: [
+    "@typespec/http",
+    "@typespec/sse",
+    "@typespec/events",
+    "typespec-rust-emitter",
+  ],
 }).emit("typespec-rust-emitter");
 
 export async function emitWithDiagnostics(