typespec-rust-emitter 0.10.2 → 0.10.5

package/example/lib/learning/models.tsp

@@ -1,4 +1,7 @@
 import "typespec-rust-emitter";
+import "@typespec/events";
+
+using TypeSpec.Events;
 
 namespace Mtlkms.Learning.Models {
   // ── COMMON ─────────────────────────────────────────────────────────────────
@@ -55,6 +58,11 @@ namespace Mtlkms.Learning.Models {
     durationMonth: int64;
   }
 
+  model CalendarHeatmapItem {
+    date: string;
+    duration: int64;
+  }
+
   // ── MODELS: GROUP ─────────────────────────────────────────────────────────
 
   model Group {
@@ -172,6 +180,41 @@ namespace Mtlkms.Learning.Models {
     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;

package/example/lib/learning/operations.tsp

@@ -1,7 +1,9 @@
 import "@typespec/http";
+import "@typespec/sse";
 import "./models.tsp";
 
 using TypeSpec.Http;
+using TypeSpec.SSE;
 using Mtlkms.Learning.Models;
 
 @route("/accounts/{accountId}/learning")
@@ -20,6 +22,23 @@ namespace Groups {
     @body error: ApiError;
   };
 
+  @get
+  @route("/calendar")
+  @doc("Get calendar heatmap data for a specific group by month.")
+  op calendar(
+    @path accountId: Uuid,
+    @path groupId: Uuid,
+    @query userTimezone: string,
+    @query year: int32,
+    @query month: int32,
+  ): {
+    @statusCode statusCode: 200;
+    @body body: CalendarHeatmapItem[];
+  } | {
+    @statusCode statusCode: 401;
+    @body error: ApiError;
+  };
+
   @post
   @useAuth(BearerAuth)
   @doc("Create a new group.")
@@ -331,3 +350,15 @@ namespace Sessions {
         error: ConflictError;
       };
 }
+
+@route("/accounts/{accountId}")
+@tag("Account")
+namespace Accounts {
+  @get
+  @route("/events")
+  @doc("Server-Sent Events stream for learning data changes.")
+  op events(
+    @path accountId: Uuid,
+    @header accept: string = "text/event-stream",
+  ): SSEStream<LearningEvents>;
+}

package/example/output-rust/Cargo.lock

@@ -393,6 +393,21 @@ dependencies = [
  "percent-encoding",
 ]
 
+[[package]]
+name = "futures"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b147ee9d1f6d097cef9ce628cd2ee62288d963e16fb287bd9286455b241382d"
+dependencies = [
+ "futures-channel",
+ "futures-core",
+ "futures-executor",
+ "futures-io",
+ "futures-sink",
+ "futures-task",
+ "futures-util",
+]
+
 [[package]]
 name = "futures-channel"
 version = "0.3.32"
@@ -437,6 +452,17 @@ version = "0.3.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cecba35d7ad927e23624b22ad55235f2239cfa44fd10428eecbeba6d6a717718"
 
+[[package]]
+name = "futures-macro"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e835b70203e41293343137df5c0664546da5745f82ec9b84d40be8336958447b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "futures-sink"
 version = "0.3.32"
@@ -455,8 +481,10 @@ version = "0.3.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "389ca41296e6190b48053de0321d02a77f32f8a5d2461dd38762c0593805c6d6"
 dependencies = [
+ "futures-channel",
  "futures-core",
  "futures-io",
+ "futures-macro",
  "futures-sink",
  "futures-task",
  "memchr",
@@ -979,6 +1007,7 @@ dependencies = [
  "axum",
  "chrono",
  "eyre",
+ "futures",
  "regex",
  "serde",
  "serde_json",

package/example/output-rust/Cargo.toml

@@ -4,6 +4,7 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
+futures = "0.3"
 regex = "1.12.3"
 serde = { version = "1.0.228", features = ["derive"] }
 serde_json = "1.0.149"

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

@@ -16,6 +16,8 @@ pub trait Server: Send + Sync {
 
     /// Retrieve a list of all groups for the current account (from view_learning_group).
     async fn groups_list(&self, account_id: uuid::Uuid) -> Result<GroupsListResponse>;
+    /// Get calendar heatmap data for a specific group by month.
+    async fn groups_calendar(&self, account_id: uuid::Uuid, group_id: uuid::Uuid, user_timezone: String, year: i32, month: i32) -> Result<GroupsCalendarResponse>;
     /// Create a new group.
     async fn groups_create(&self, claims: Self::Claims, account_id: uuid::Uuid, body: CreateGroupBody) -> Result<GroupsCreateResponse>;
     /// Get the details of a group by its ID.
@@ -50,7 +52,10 @@ pub trait Server: Send + Sync {
 /// The server closes the current Timelog if it is running, and updates Log.stoppedAt.
 /// Returns 409 if the session is already Stopped.
     async fn sessions_stop(&self, claims: Self::Claims, account_id: uuid::Uuid, subject_id: i64, log_id: i64, body: SessionNoteBody) -> Result<SessionsStopResponse>;
+    /// Server-Sent Events stream for learning data changes.
+    async fn accounts_events(&self, account_id: uuid::Uuid) -> Result<AccountsEventsResponse>;
 }
+#[allow(clippy::type_complexity)]
 pub enum GroupsListResponse {
     Ok(Json<Vec<GroupStatistics>>),
     Unauthorized(Json<ApiError>),
@@ -66,6 +71,23 @@ impl IntoResponse for GroupsListResponse {
     }
 }
 
+#[allow(clippy::type_complexity)]
+pub enum GroupsCalendarResponse {
+    Ok(Json<Vec<CalendarHeatmapItem>>),
+    Unauthorized(Json<ApiError>),
+}
+
+impl IntoResponse for GroupsCalendarResponse {
+    fn into_response(self) -> axum::response::Response {
+        match self {
+
+            GroupsCalendarResponse::Ok(body) => (StatusCode::OK, body).into_response(),
+            GroupsCalendarResponse::Unauthorized(body) => (StatusCode::UNAUTHORIZED, body).into_response(),
+        }
+    }
+}
+
+#[allow(clippy::type_complexity)]
 pub enum GroupsCreateResponse {
     Created(Json<Group>),
     BadRequest(Json<ValidationError>),
@@ -83,6 +105,7 @@ impl IntoResponse for GroupsCreateResponse {
     }
 }
 
+#[allow(clippy::type_complexity)]
 pub enum GroupsGetByIdResponse {
     Ok(Json<GroupStatistics>),
     Unauthorized(Json<ApiError>),
@@ -100,6 +123,7 @@ impl IntoResponse for GroupsGetByIdResponse {
     }
 }
 
+#[allow(clippy::type_complexity)]
 pub enum GroupsUpdateResponse {
     Ok(Json<Group>),
     BadRequest(Json<ValidationError>),
@@ -119,6 +143,7 @@ impl IntoResponse for GroupsUpdateResponse {
     }
 }
 
+#[allow(clippy::type_complexity)]
 pub enum GroupsDeleteResponse {
     NoContent,
     Unauthorized(Json<ApiError>),
@@ -136,6 +161,7 @@ impl IntoResponse for GroupsDeleteResponse {
     }
 }
 
+#[allow(clippy::type_complexity)]
 pub enum SubjectsListResponse {
     Ok(Json<Vec<SubjectStatistics>>),
     Unauthorized(Json<ApiError>),
@@ -153,6 +179,7 @@ impl IntoResponse for SubjectsListResponse {
     }
 }
 
+#[allow(clippy::type_complexity)]
 pub enum SubjectsCreateResponse {
     Created(Json<Subject>),
     BadRequest(Json<ValidationError>),
@@ -172,6 +199,7 @@ impl IntoResponse for SubjectsCreateResponse {
     }
 }
 
+#[allow(clippy::type_complexity)]
 pub enum SubjectsGetByIdResponse {
     Ok(Json<SubjectStatistics>),
     Unauthorized(Json<ApiError>),
@@ -189,6 +217,7 @@ impl IntoResponse for SubjectsGetByIdResponse {
     }
 }
 
+#[allow(clippy::type_complexity)]
 pub enum SubjectsUpdateResponse {
     Ok(Json<Subject>),
     BadRequest(Json<ValidationError>),
@@ -208,6 +237,7 @@ impl IntoResponse for SubjectsUpdateResponse {
     }
 }
 
+#[allow(clippy::type_complexity)]
 pub enum SubjectsDeleteResponse {
     NoContent,
     Unauthorized(Json<ApiError>),
@@ -225,6 +255,7 @@ impl IntoResponse for SubjectsDeleteResponse {
     }
 }
 
+#[allow(clippy::type_complexity)]
 pub enum SessionsStartResponse {
     Created(Json<SessionOpenedResponse>),
     Unauthorized(Json<ApiError>),
@@ -244,6 +275,7 @@ impl IntoResponse for SessionsStartResponse {
     }
 }
 
+#[allow(clippy::type_complexity)]
 pub enum SessionsPauseResponse {
     Ok(Json<SessionClosedResponse>),
     Unauthorized(Json<ApiError>),
@@ -263,6 +295,7 @@ impl IntoResponse for SessionsPauseResponse {
     }
 }
 
+#[allow(clippy::type_complexity)]
 pub enum SessionsResumeResponse {
     Ok(Json<SessionOpenedResponse>),
     Unauthorized(Json<ApiError>),
@@ -282,6 +315,7 @@ impl IntoResponse for SessionsResumeResponse {
     }
 }
 
+#[allow(clippy::type_complexity)]
 pub enum SessionsStopResponse {
     Ok(Json<SessionClosedResponse>),
     Unauthorized(Json<ApiError>),
@@ -301,10 +335,34 @@ impl IntoResponse for SessionsStopResponse {
     }
 }
 
+#[allow(clippy::type_complexity)]
+pub enum AccountsEventsResponse {
+    Ok(axum::response::sse::Sse<std::pin::Pin<Box<dyn futures::stream::Stream<Item = Result<axum::response::sse::Event, std::convert::Infallible>> + Send>>>),
+}
+
+impl IntoResponse for AccountsEventsResponse {
+    fn into_response(self) -> axum::response::Response {
+        match self {
+
+            AccountsEventsResponse::Ok(body) => body.into_response(),
+        }
+    }
+}
+
+use axum::extract::Query;
 use axum::routing::{delete, get, patch, post};
 use axum::Router;
 
 
+#[derive(Debug, Clone, serde::Deserialize)]
+pub struct GroupsCalendarQuery {
+    pub user_timezone: String,
+    pub year: i32,
+    pub month: i32
+}
+
+
+
 pub async fn groups_list_handler<S>(
     axum::extract::State(service): axum::extract::State<S>,
     Path(account_id): Path<uuid::Uuid>,
@@ -324,6 +382,26 @@ where
     }
 }
 
+pub async fn groups_calendar_handler<S>(
+    axum::extract::State(service): axum::extract::State<S>,
+    Path((account_id, group_id)): Path<(uuid::Uuid, uuid::Uuid)>,
+    Query(params): Query<GroupsCalendarQuery>,
+) -> impl axum::response::IntoResponse
+where
+    S: Server + Clone + Send + Sync + 'static,
+    S::Claims: Send + Sync + Clone + 'static,
+{
+    let result = service.groups_calendar(account_id, group_id, params.user_timezone, params.year, params.month).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 groups_create_handler<S>(
     axum::extract::State(service): axum::extract::State<S>,
     Extension(claims): Extension<S::Claims>,
@@ -587,6 +665,25 @@ where
     }
 }
 
+pub async fn accounts_events_handler<S>(
+    axum::extract::State(service): axum::extract::State<S>,
+    Path(account_id): Path<uuid::Uuid>,
+) -> impl axum::response::IntoResponse
+where
+    S: Server + Clone + Send + Sync + 'static,
+    S::Claims: Send + Sync + Clone + 'static,
+{
+    let result = service.accounts_events(account_id).await;
+    match result {
+        Ok(response) => response.into_response(),
+        Err(e) => (
+            axum::http::StatusCode::INTERNAL_SERVER_ERROR,
+            format!("Internal error: {e}"),
+        )
+            .into_response(),
+    }
+}
+
 pub fn create_router<S, M>(service: S, middleware: M) -> Router
 where
     S: Server + Clone + Send + Sync + 'static,
@@ -596,9 +693,11 @@ where
     let mut router = Router::new();
     let public = Router::new()
         .route("/accounts/{accountId}/learning/groups", get(groups_list_handler::<S>))
+        .route("/accounts/{accountId}/learning/groups/calendar", get(groups_calendar_handler::<S>))
         .route("/accounts/{accountId}/learning/groups/{id}", get(groups_get_by_id_handler::<S>))
         .route("/accounts/{accountId}/learning/groups/{groupId}/subjects", get(subjects_list_handler::<S>))
         .route("/accounts/{accountId}/learning/groups/{groupId}/subjects/{id}", get(subjects_get_by_id_handler::<S>))
+        .route("/accounts/{accountId}/learning/accounts/{accountId}/events", get(accounts_events_handler::<S>))
         ;
     router = router.merge(public);
     let protected = Router::new()

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

@@ -5,8 +5,7 @@ use axum::http::StatusCode;
 use axum::response::IntoResponse;
 use axum::Json;
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, thiserror::Error)]
-#[error("{code}: {message}")]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct ApiError {
   /// Machine-readable error code.
   pub code: String,
@@ -14,70 +13,27 @@ pub struct ApiError {
   pub message: String,
 }
 
-impl IntoResponse for ApiError {
-    fn into_response(self) -> axum::response::Response {
-        (
-            StatusCode::from_str(&self.code).unwrap_or(StatusCode::INTERNAL_SERVER_ERROR),
-            Json(self),
-        )
-            .into_response()
-    }
-}
-
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, thiserror::Error)]
-#[error("{code}: {message}")]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct NotFoundError {
   pub code: String,
   /// Human-readable message.
   pub message: String,
 }
 
-impl IntoResponse for NotFoundError {
-    fn into_response(self) -> axum::response::Response {
-        (
-            StatusCode::from_str(&self.code).unwrap_or(StatusCode::INTERNAL_SERVER_ERROR),
-            Json(self),
-        )
-            .into_response()
-    }
-}
-
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, thiserror::Error)]
-#[error("{code}: {message}")]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct ValidationError {
   pub code: String,
   /// Human-readable message.
   pub message: String,
 }
 
-impl IntoResponse for ValidationError {
-    fn into_response(self) -> axum::response::Response {
-        (
-            StatusCode::from_str(&self.code).unwrap_or(StatusCode::INTERNAL_SERVER_ERROR),
-            Json(self),
-        )
-            .into_response()
-    }
-}
-
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, thiserror::Error)]
-#[error("{code}: {message}")]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct ConflictError {
   pub code: String,
   /// Human-readable message.
   pub message: String,
 }
 
-impl IntoResponse for ConflictError {
-    fn into_response(self) -> axum::response::Response {
-        (
-            StatusCode::from_str(&self.code).unwrap_or(StatusCode::INTERNAL_SERVER_ERROR),
-            Json(self),
-        )
-            .into_response()
-    }
-}
-
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct DurationStats {
   #[serde(rename = "durationTotal")]
@@ -90,6 +46,12 @@ pub struct DurationStats {
   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,
@@ -263,6 +225,44 @@ pub struct Timelog {
   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,
@@ -282,6 +282,46 @@ pub struct SessionNoteBody {
   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 {
@@ -307,6 +347,14 @@ pub enum ChartGranularity {
   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)]