typespec-rust-emitter 0.10.5 → 0.10.7

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

@@ -6,366 +6,13 @@ use axum::response::IntoResponse;
 use axum::Json;
 
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
-pub struct ApiError {
-  /// Machine-readable error code.
-  pub code: String,
-  /// Human-readable message.
+pub struct MyEventData {
   pub message: String,
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
-pub struct NotFoundError {
-  pub code: String,
-  /// Human-readable message.
-  pub message: String,
-}
-
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
-pub struct ValidationError {
-  pub code: String,
-  /// Human-readable message.
-  pub message: String,
-}
-
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
-pub struct ConflictError {
-  pub code: String,
-  /// Human-readable message.
-  pub message: String,
-}
-
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
-pub struct DurationStats {
-  #[serde(rename = "durationTotal")]
-  pub duration_total: i64,
-  #[serde(rename = "durationDay")]
-  pub duration_day: i64,
-  #[serde(rename = "durationWeek")]
-  pub duration_week: i64,
-  #[serde(rename = "durationMonth")]
-  pub duration_month: i64,
-}
-
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
-pub struct CalendarHeatmapItem {
-  pub date: String,
-  pub duration: i64,
-}
-
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
-pub struct Group {
-  pub id: i64,
-  #[serde(rename = "accountId")]
-  pub account_id: uuid::Uuid,
-  #[serde(rename = "createdAt")]
-  pub created_at: chrono::DateTime<chrono::Utc>,
-  #[serde(rename = "deletedAt")]
-  pub deleted_at: Option<chrono::DateTime<chrono::Utc>>,
-  pub name: String,
-  pub icon: String,
-  #[serde(rename = "colorText")]
-  pub color_text: HexColor,
-  #[serde(rename = "colorBg")]
-  pub color_bg: HexColor,
-}
-
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, sqlx::FromRow)]
-pub struct GroupStatistics {
-  pub id: i64,
-  #[serde(rename = "accountId")]
-  pub account_id: uuid::Uuid,
-  #[serde(rename = "createdAt")]
-  pub created_at: chrono::DateTime<chrono::Utc>,
-  #[serde(rename = "deletedAt")]
-  pub deleted_at: Option<chrono::DateTime<chrono::Utc>>,
-  pub name: String,
-  pub icon: String,
-  #[serde(rename = "colorText")]
-  pub color_text: HexColor,
-  #[serde(rename = "colorBg")]
-  pub color_bg: HexColor,
-  #[serde(rename = "subjectCount")]
-  pub subject_count: i64,
-  pub status: StudyStatus,
-  #[serde(rename = "durationTotal")]
-  pub duration_total: i64,
-  #[serde(rename = "durationDay")]
-  pub duration_day: i64,
-  #[serde(rename = "durationWeek")]
-  pub duration_week: i64,
-  #[serde(rename = "durationMonth")]
-  pub duration_month: i64,
-}
-
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
-pub struct CreateGroupBody {
-  pub name: String,
-  pub icon: String,
-  #[serde(rename = "colorText")]
-  pub color_text: HexColor,
-  #[serde(rename = "colorBg")]
-  pub color_bg: HexColor,
-}
-
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
-pub struct UpdateGroupBody {
-  #[serde(skip_serializing_if = "Option::is_none")]
-  pub name: Option<String>,
-  #[serde(skip_serializing_if = "Option::is_none")]
-  pub icon: Option<String>,
-  #[serde(rename = "colorText")]
-  #[serde(skip_serializing_if = "Option::is_none")]
-  pub color_text: Option<HexColor>,
-  #[serde(rename = "colorBg")]
-  #[serde(skip_serializing_if = "Option::is_none")]
-  pub color_bg: Option<HexColor>,
-}
-
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
-pub struct Subject {
-  pub id: i64,
-  #[serde(rename = "accountId")]
-  pub account_id: uuid::Uuid,
-  #[serde(rename = "groupId")]
-  pub group_id: i64,
-  #[serde(rename = "createdAt")]
-  pub created_at: chrono::DateTime<chrono::Utc>,
-  #[serde(rename = "deletedAt")]
-  pub deleted_at: Option<chrono::DateTime<chrono::Utc>>,
-  pub name: String,
-  pub icon: String,
-  #[serde(rename = "colorText")]
-  pub color_text: HexColor,
-  #[serde(rename = "colorBg")]
-  pub color_bg: HexColor,
-}
-
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
-pub struct SubjectStatistics {
-  pub id: i64,
-  #[serde(rename = "accountId")]
-  pub account_id: uuid::Uuid,
-  #[serde(rename = "groupId")]
-  pub group_id: i64,
-  #[serde(rename = "createdAt")]
-  pub created_at: chrono::DateTime<chrono::Utc>,
-  #[serde(rename = "deletedAt")]
-  pub deleted_at: Option<chrono::DateTime<chrono::Utc>>,
-  pub name: String,
-  pub icon: String,
-  #[serde(rename = "colorText")]
-  pub color_text: HexColor,
-  #[serde(rename = "colorBg")]
-  pub color_bg: HexColor,
-  pub status: StudyStatus,
-  #[serde(rename = "durationTotal")]
-  pub duration_total: i64,
-  #[serde(rename = "durationDay")]
-  pub duration_day: i64,
-  #[serde(rename = "durationWeek")]
-  pub duration_week: i64,
-  #[serde(rename = "durationMonth")]
-  pub duration_month: i64,
-}
-
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
-pub struct CreateSubjectBody {
-  pub name: String,
-  pub icon: String,
-  #[serde(rename = "colorText")]
-  pub color_text: HexColor,
-  #[serde(rename = "colorBg")]
-  pub color_bg: HexColor,
-}
-
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
-pub struct UpdateSubjectBody {
-  #[serde(skip_serializing_if = "Option::is_none")]
-  pub name: Option<String>,
-  #[serde(skip_serializing_if = "Option::is_none")]
-  pub icon: Option<String>,
-  #[serde(rename = "colorText")]
-  #[serde(skip_serializing_if = "Option::is_none")]
-  pub color_text: Option<HexColor>,
-  #[serde(rename = "colorBg")]
-  #[serde(skip_serializing_if = "Option::is_none")]
-  pub color_bg: Option<HexColor>,
-}
-
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
-pub struct Log {
-  pub id: i64,
-  #[serde(rename = "accountId")]
-  pub account_id: uuid::Uuid,
-  #[serde(rename = "subjectId")]
-  pub subject_id: i64,
-  #[serde(rename = "startedAt")]
-  pub started_at: chrono::DateTime<chrono::Utc>,
-  #[serde(rename = "stoppedAt")]
-  pub stopped_at: Option<chrono::DateTime<chrono::Utc>>,
-  #[serde(rename = "logContent")]
-  pub log_content: Option<String>,
-  pub status: StudyStatus,
-}
-
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
-pub struct Timelog {
-  pub id: i64,
-  #[serde(rename = "accountId")]
-  pub account_id: uuid::Uuid,
-  #[serde(rename = "logId")]
-  pub log_id: i64,
-  #[serde(rename = "subjectId")]
-  pub subject_id: i64,
-  #[serde(rename = "startedAt")]
-  pub started_at: chrono::DateTime<chrono::Utc>,
-  #[serde(rename = "stoppedAt")]
-  pub stopped_at: Option<chrono::DateTime<chrono::Utc>>,
-  #[serde(rename = "durationInSeconds")]
-  pub duration_in_seconds: i64,
-}
-
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
-pub struct LogWithTimelogs {
-  pub id: i64,
-  #[serde(rename = "accountId")]
-  pub account_id: uuid::Uuid,
-  #[serde(rename = "subjectId")]
-  pub subject_id: i64,
-  #[serde(rename = "startedAt")]
-  pub started_at: chrono::DateTime<chrono::Utc>,
-  #[serde(rename = "stoppedAt")]
-  pub stopped_at: Option<chrono::DateTime<chrono::Utc>>,
-  #[serde(rename = "logContent")]
-  pub log_content: Option<String>,
-  pub status: StudyStatus,
-  pub timelogs: Vec<Timelog>,
-}
-
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
-pub struct SessionEvent {
-  #[serde(rename = "eventType")]
-  pub event_type: EnumSessionSessionpause4,
-  pub session: LogWithTimelogs,
-}
-
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
-pub struct GroupEvent {
-  #[serde(rename = "eventType")]
-  pub event_type: EnumGroupcreatedGroupupdated3,
-  pub group: Group,
-}
-
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
-pub struct SubjectEvent {
-  #[serde(rename = "eventType")]
-  pub event_type: EnumSubjectcreatedSubjectupdated4,
-  pub subject: Subject,
-}
-
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
-pub struct SessionOpenedResponse {
-  pub log: Log,
-  pub timelog: Timelog,
-}
-
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
-pub struct SessionClosedResponse {
-  pub log: Log,
-  pub timelog: Timelog,
-}
-
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
-pub struct SessionNoteBody {
-  #[serde(rename = "logContent")]
-  #[serde(skip_serializing_if = "Option::is_none")]
-  pub log_content: Option<String>,
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default, serde::Serialize, serde::Deserialize)]
-#[allow(clippy::enum_variant_names)]
-pub enum EnumSessionSessionpause4 {
-  #[default]
-  #[serde(rename = "session")]
-  Session,
-  #[serde(rename = "session_pause")]
-  SessionPause,
-  #[serde(rename = "session_resume")]
-  SessionResume,
-  #[serde(rename = "session_stop")]
-  SessionStop,
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default, serde::Serialize, serde::Deserialize)]
-#[allow(clippy::enum_variant_names)]
-pub enum EnumGroupcreatedGroupupdated3 {
-  #[default]
-  #[serde(rename = "group_created")]
-  GroupCreated,
-  #[serde(rename = "group_updated")]
-  GroupUpdated,
-  #[serde(rename = "group_deleted")]
-  GroupDeleted,
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default, serde::Serialize, serde::Deserialize)]
-#[allow(clippy::enum_variant_names)]
-pub enum EnumSubjectcreatedSubjectupdated4 {
-  #[default]
-  #[serde(rename = "subject_created")]
-  SubjectCreated,
-  #[serde(rename = "subject_updated")]
-  SubjectUpdated,
-  #[serde(rename = "subject_deleted")]
-  SubjectDeleted,
-  #[serde(rename = "subject_moved")]
-  SubjectMoved,
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default, serde::Serialize, serde::Deserialize, sqlx::Type)]
-#[sqlx(type_name = "study_status")]
-pub enum StudyStatus {
-  #[default]
-  #[serde(rename = "Starting")]
-  Starting,
-  #[serde(rename = "Paused")]
-  Paused,
-  #[serde(rename = "Stopped")]
-  Stopped,
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default, serde::Serialize, serde::Deserialize)]
-pub enum ChartGranularity {
-  #[default]
-  #[serde(rename = "day")]
-  Day,
-  #[serde(rename = "week")]
-  Week,
-  #[serde(rename = "month")]
-  Month,
-  #[serde(rename = "year")]
-  Year,
-}
-
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 #[serde(untagged)]
-pub enum LearningEvents {
-  Variant1(SessionEvent),
-  Variant2(GroupEvent),
-  Variant3(SubjectEvent),
-}
-
-pub type Uuid = uuid::Uuid;
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, serde::Serialize, serde::Deserialize)]
-pub struct HexColor(pub String);
-
-impl TryFrom<String> for HexColor {
-  type Error = String;
-
-  fn try_from(value: String) -> Result<Self, Self::Error> {
-    let re = regex::Regex::new(r"^#[0-9A-Fa-f]{6}$").unwrap();
-    if re.is_match(&value) { Ok(Self(value)) } else { Err(format!("Invalid value: {}", value)) }
-  }
+pub enum MyEvent {
+  Variant1(MyEventData),
 }
 

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

@@ -1,5 +1,117 @@
 mod generated;
 
-fn main() {
-    println!("Hello, world!");
+use async_trait::async_trait;
+use axum::response::IntoResponse;
+use axum::response::sse::{Event, KeepAlive, Sse};
+use generated::server::{EventsAccountsEventsResponse, 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;
+
+#[async_trait]
+impl Server for AppState {
+    type Claims = ();
+
+    async fn events_accounts_events(
+        &self,
+        _account_id: String,
+    ) -> eyre::Result<EventsAccountsEventsResponse> {
+        let stream = IntervalStream::new(interval(Duration::from_millis(100)))
+            .map(|_| Ok::<_, Infallible>(Event::default().data("hi!")))
+            .take(3); // emit 3 events
+
+        let stream = Sse::new(stream).keep_alive(KeepAlive::default());
+        Ok(EventsAccountsEventsResponse::Ok(stream.into_response()))
+    }
+
+    async fn pets_list(
+        &self,
+        _first_query: String,
+        _second_query: String,
+    ) -> eyre::Result<PetsListResponse> {
+        todo!()
+    }
+}
+
+#[tokio::main]
+async fn main() {
+    let app = generated::server::create_router(AppState, |r| r);
+    let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
+    println!("Server running on {}", listener.local_addr().unwrap());
+    axum::serve(listener, app).await.unwrap();
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use axum::http::Request;
+    use http_body_util::BodyExt;
+    use tower::ServiceExt;
+
+    #[tokio::test]
+    async fn test_sse_endpoint() {
+        // Wait! The generated route in `example/output-rust/src/generated/server.rs` uses `/events/{accountId}` literally!
+        // We might need to use `/events/{accountId}` in the request to match, or fix the emitter if it's broken.
+        // Let's use whatever route is in the generated code to test the SSE handler logic first.
+        let app = generated::server::create_router(AppState, |r| r);
+
+        let req = Request::builder()
+            .uri("/events/123") // If the emitter generates {accountId}, axum won't match this if it requires `:accountId`.
+            // Wait, actually I should check if axum matches {accountId} or if it fails.
+            .body(axum::body::Body::empty())
+            .unwrap();
+
+        let response = app.oneshot(req).await.unwrap();
+
+        // If axum doesn't match, we will get 404. Let's handle both.
+        if response.status() == 404 {
+            let req2 = Request::builder()
+                .uri("/events/{accountId}")
+                .body(axum::body::Body::empty())
+                .unwrap();
+            let app = generated::server::create_router(AppState, |r| r);
+            let response2 = app.oneshot(req2).await.unwrap();
+            assert_eq!(response2.status(), 200);
+            return;
+        }
+
+        assert_eq!(response.status(), 200);
+        assert_eq!(
+            response.headers().get("content-type").unwrap(),
+            "text/event-stream"
+        );
+
+        // Read body frames sequentially
+        let mut body = response.into_body();
+        let mut timestamps = Vec::new();
+
+        while let Some(Ok(frame)) = body.frame().await {
+            if let Some(data) = frame.data_ref() {
+                let text = String::from_utf8_lossy(data);
+                if text.contains("data: hi!") {
+                    timestamps.push(std::time::Instant::now());
+                }
+            }
+        }
+
+        // We should have received 3 events
+        assert_eq!(timestamps.len(), 3);
+
+        // Verify delay between events (approx 100ms)
+        for i in 1..timestamps.len() {
+            let diff = timestamps[i].duration_since(timestamps[i - 1]);
+            // Give it some slack for CI / slow execution, but ensure it's not instantaneous
+            assert!(
+                diff.as_millis() >= 80,
+                "Events were too fast! Diff: {}ms",
+                diff.as_millis()
+            );
+        }
+    }
 }

package/example/package-lock.json

@@ -19,12 +19,14 @@
       }
     },
     "..": {
-      "version": "0.10.3",
+      "version": "0.10.6",
       "license": "MIT",
       "devDependencies": {
         "@types/node": "latest",
         "@typespec/compiler": "latest",
+        "@typespec/events": "^0.81.0",
         "@typespec/http": "^1.11.0",
+        "@typespec/sse": "^0.81.0",
         "eslint": "^9.15.0",
         "prettier": "^3.3.3",
         "typescript": "^5.3.3",

package/package.json

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

package/src/emitter.ts

@@ -393,7 +393,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;
@@ -412,8 +433,7 @@ function getOperationResponses(
     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>>>",
+        bodyType: "axum::response::Response",
         bodyDescription: "Server-Sent Events stream",
         isSse: true,
       });
@@ -467,7 +487,7 @@ function getBodyFromResponse(
     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>>>",
+        type: "axum::response::Response",
         description: "Server-Sent Events stream",
         isSse: true,
       };
@@ -851,7 +871,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}`,

package/test/hello.test.ts

@@ -435,12 +435,7 @@ describe("Rust emitter", () => {
       }
     `);
     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("axum::response::Response"), true);
     strictEqual(
       server.includes(
         "EventsStreamResponse::Ok(body) => body.into_response(),",