typespec-rust-emitter 0.10.3 → 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;
@@ -712,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")}
 }
 `);
@@ -732,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(),`,
@@ -1058,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,
@@ -1211,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]`);
@@ -1547,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]`);
       }

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 {
@@ -400,4 +411,41 @@ describe("Rust emitter", () => {
     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/http", "typespec-rust-emitter"],
+  libraries: [
+    "@typespec/http",
+    "@typespec/sse",
+    "@typespec/events",
+    "typespec-rust-emitter",
+  ],
 }).emit("typespec-rust-emitter");
 
 export async function emitWithDiagnostics(