typespec-rust-emitter 0.4.0 → 0.6.0

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

@@ -1,3 +1,5 @@
+#![allow(unused)]
+
 use super::types::*;
 use async_trait::async_trait;
 use axum::{http::StatusCode, Json};
@@ -11,41 +13,41 @@ pub trait Server: Send + Sync {
 
 
     /// Retrieve a list of all groups for the current account (from view_learning_group).
-    async fn groups_list(&self) -> Result<GroupsListResponse>;
+    async fn groups_list(&self, account_id: uuid::Uuid) -> Result<GroupsListResponse>;
     /// Create a new group.
-    async fn groups_create(&self, claims: Self::Claims, body: CreateGroupBody) -> Result<GroupsCreateResponse>;
+    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.
-    async fn groups_get_by_id(&self, id: i64) -> Result<GroupsGetByIdResponse>;
+    async fn groups_get_by_id(&self, account_id: uuid::Uuid, id: i64) -> Result<GroupsGetByIdResponse>;
     /// Update a group. Only provide the fields that need to be changed.
-    async fn groups_update(&self, claims: Self::Claims, id: i64, body: UpdateGroupBody) -> Result<GroupsUpdateResponse>;
+    async fn groups_update(&self, claims: Self::Claims, account_id: uuid::Uuid, id: i64, body: UpdateGroupBody) -> Result<GroupsUpdateResponse>;
     /// Soft delete a group. All subjects within the group will also be soft deleted.
-    async fn groups_delete(&self, claims: Self::Claims, id: i64) -> Result<GroupsDeleteResponse>;
+    async fn groups_delete(&self, claims: Self::Claims, account_id: uuid::Uuid, id: i64) -> Result<GroupsDeleteResponse>;
     /// Retrieve a list of subjects for a group (from view_subject_statistics).
-    async fn subjects_list(&self, group_id: i64) -> Result<SubjectsListResponse>;
+    async fn subjects_list(&self, account_id: uuid::Uuid, group_id: i64) -> Result<SubjectsListResponse>;
     /// Create a new subject within the specified group.
-    async fn subjects_create(&self, claims: Self::Claims, group_id: i64, body: CreateSubjectBody) -> Result<SubjectsCreateResponse>;
+    async fn subjects_create(&self, claims: Self::Claims, account_id: uuid::Uuid, group_id: i64, body: CreateSubjectBody) -> Result<SubjectsCreateResponse>;
     /// Get the details of a subject by its ID.
-    async fn subjects_get_by_id(&self, group_id: i64, id: i64) -> Result<SubjectsGetByIdResponse>;
+    async fn subjects_get_by_id(&self, account_id: uuid::Uuid, group_id: i64, id: i64) -> Result<SubjectsGetByIdResponse>;
     /// Update a subject. Only provide the fields that need to be changed.
-    async fn subjects_update(&self, claims: Self::Claims, group_id: i64, id: i64, body: UpdateSubjectBody) -> Result<SubjectsUpdateResponse>;
+    async fn subjects_update(&self, claims: Self::Claims, account_id: uuid::Uuid, group_id: i64, id: i64, body: UpdateSubjectBody) -> Result<SubjectsUpdateResponse>;
     /// Soft delete a subject.
-    async fn subjects_delete(&self, claims: Self::Claims, group_id: i64, id: i64) -> Result<SubjectsDeleteResponse>;
+    async fn subjects_delete(&self, claims: Self::Claims, account_id: uuid::Uuid, group_id: i64, id: i64) -> Result<SubjectsDeleteResponse>;
     /// Start a new study session for the subject.
 /// The server creates a Log (status=Starting) and the first Timelog.
 /// Returns 409 if the subject already has a session in Starting or Paused status.
-    async fn sessions_start(&self, claims: Self::Claims, subject_id: i64, body: SessionNoteBody) -> Result<SessionsStartResponse>;
+    async fn sessions_start(&self, claims: Self::Claims, account_id: uuid::Uuid, subject_id: i64, body: SessionNoteBody) -> Result<SessionsStartResponse>;
     /// Pause the currently running session (transition from Starting to Paused).
 /// The server closes the current Timelog (sets stoppedAt and calculates durationInSeconds).
 /// Returns 409 if the session is not in the Starting state.
-    async fn sessions_pause(&self, claims: Self::Claims, subject_id: i64, log_id: i64) -> Result<SessionsPauseResponse>;
+    async fn sessions_pause(&self, claims: Self::Claims, account_id: uuid::Uuid, subject_id: i64, log_id: i64) -> Result<SessionsPauseResponse>;
     /// Resume a paused session (transition from Paused to Starting).
 /// The server creates a new Timelog.
 /// Returns 409 if the session is not in the Paused state.
-    async fn sessions_resume(&self, claims: Self::Claims, subject_id: i64, log_id: i64) -> Result<SessionsResumeResponse>;
+    async fn sessions_resume(&self, claims: Self::Claims, account_id: uuid::Uuid, subject_id: i64, log_id: i64) -> Result<SessionsResumeResponse>;
     /// End the session (transition from Starting or Paused to Stopped).
 /// 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, subject_id: i64, log_id: i64, body: SessionNoteBody) -> Result<SessionsStopResponse>;
+    async fn sessions_stop(&self, claims: Self::Claims, account_id: uuid::Uuid, subject_id: i64, log_id: i64, body: SessionNoteBody) -> Result<SessionsStopResponse>;
 }
 pub enum GroupsListResponse {
     Ok(Json<Vec<GroupStatistics>>),
@@ -304,13 +306,13 @@ use axum::Router;
 
 pub async fn groups_list_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.groups_list().await;
+    let result = service.groups_list(account_id).await;
     match result {
         Ok(response) => response.into_response(),
         Err(e) => (
@@ -324,13 +326,14 @@ where
 pub async fn groups_create_handler<S>(
     axum::extract::State(service): axum::extract::State<S>,
     Extension(claims): Extension<S::Claims>,
+    Path(account_id): Path<uuid::Uuid>,
     Json(payload): Json<CreateGroupBody>,
 ) -> impl axum::response::IntoResponse
 where
     S: Server + Clone + Send + Sync + 'static,
     S::Claims: Send + Sync + Clone + 'static,
 {
-    let result = service.groups_create(claims, payload).await;
+    let result = service.groups_create(claims, account_id, payload).await;
     match result {
         Ok(response) => response.into_response(),
         Err(e) => (
@@ -343,13 +346,13 @@ where
 
 pub async fn groups_get_by_id_handler<S>(
     axum::extract::State(service): axum::extract::State<S>,
-    Path(id): Path<i64>,
+    Path((account_id, id)): Path<(uuid::Uuid, i64)>,
 ) -> impl axum::response::IntoResponse
 where
     S: Server + Clone + Send + Sync + 'static,
     S::Claims: Send + Sync + Clone + 'static,
 {
-    let result = service.groups_get_by_id(id).await;
+    let result = service.groups_get_by_id(account_id, id).await;
     match result {
         Ok(response) => response.into_response(),
         Err(e) => (
@@ -363,14 +366,14 @@ where
 pub async fn groups_update_handler<S>(
     axum::extract::State(service): axum::extract::State<S>,
     Extension(claims): Extension<S::Claims>,
-    Path(id): Path<i64>,
+    Path((account_id, id)): Path<(uuid::Uuid, i64)>,
     Json(payload): Json<UpdateGroupBody>,
 ) -> impl axum::response::IntoResponse
 where
     S: Server + Clone + Send + Sync + 'static,
     S::Claims: Send + Sync + Clone + 'static,
 {
-    let result = service.groups_update(claims, id, payload).await;
+    let result = service.groups_update(claims, account_id, id, payload).await;
     match result {
         Ok(response) => response.into_response(),
         Err(e) => (
@@ -384,13 +387,13 @@ where
 pub async fn groups_delete_handler<S>(
     axum::extract::State(service): axum::extract::State<S>,
     Extension(claims): Extension<S::Claims>,
-    Path(id): Path<i64>,
+    Path((account_id, id)): Path<(uuid::Uuid, i64)>,
 ) -> impl axum::response::IntoResponse
 where
     S: Server + Clone + Send + Sync + 'static,
     S::Claims: Send + Sync + Clone + 'static,
 {
-    let result = service.groups_delete(claims, id).await;
+    let result = service.groups_delete(claims, account_id, id).await;
     match result {
         Ok(response) => response.into_response(),
         Err(e) => (
@@ -403,13 +406,13 @@ where
 
 pub async fn subjects_list_handler<S>(
     axum::extract::State(service): axum::extract::State<S>,
-    Path(group_id): Path<i64>,
+    Path((account_id, group_id)): Path<(uuid::Uuid, i64)>,
 ) -> impl axum::response::IntoResponse
 where
     S: Server + Clone + Send + Sync + 'static,
     S::Claims: Send + Sync + Clone + 'static,
 {
-    let result = service.subjects_list(group_id).await;
+    let result = service.subjects_list(account_id, group_id).await;
     match result {
         Ok(response) => response.into_response(),
         Err(e) => (
@@ -423,14 +426,14 @@ where
 pub async fn subjects_create_handler<S>(
     axum::extract::State(service): axum::extract::State<S>,
     Extension(claims): Extension<S::Claims>,
-    Path(group_id): Path<i64>,
+    Path((account_id, group_id)): Path<(uuid::Uuid, i64)>,
     Json(payload): Json<CreateSubjectBody>,
 ) -> impl axum::response::IntoResponse
 where
     S: Server + Clone + Send + Sync + 'static,
     S::Claims: Send + Sync + Clone + 'static,
 {
-    let result = service.subjects_create(claims, group_id, payload).await;
+    let result = service.subjects_create(claims, account_id, group_id, payload).await;
     match result {
         Ok(response) => response.into_response(),
         Err(e) => (
@@ -443,13 +446,13 @@ where
 
 pub async fn subjects_get_by_id_handler<S>(
     axum::extract::State(service): axum::extract::State<S>,
-    Path((group_id, id)): Path<(i64, i64)>,
+    Path((account_id, group_id, id)): Path<(uuid::Uuid, i64, i64)>,
 ) -> impl axum::response::IntoResponse
 where
     S: Server + Clone + Send + Sync + 'static,
     S::Claims: Send + Sync + Clone + 'static,
 {
-    let result = service.subjects_get_by_id(group_id, id).await;
+    let result = service.subjects_get_by_id(account_id, group_id, id).await;
     match result {
         Ok(response) => response.into_response(),
         Err(e) => (
@@ -463,14 +466,14 @@ where
 pub async fn subjects_update_handler<S>(
     axum::extract::State(service): axum::extract::State<S>,
     Extension(claims): Extension<S::Claims>,
-    Path((group_id, id)): Path<(i64, i64)>,
+    Path((account_id, group_id, id)): Path<(uuid::Uuid, i64, i64)>,
     Json(payload): Json<UpdateSubjectBody>,
 ) -> impl axum::response::IntoResponse
 where
     S: Server + Clone + Send + Sync + 'static,
     S::Claims: Send + Sync + Clone + 'static,
 {
-    let result = service.subjects_update(claims, group_id, id, payload).await;
+    let result = service.subjects_update(claims, account_id, group_id, id, payload).await;
     match result {
         Ok(response) => response.into_response(),
         Err(e) => (
@@ -484,13 +487,13 @@ where
 pub async fn subjects_delete_handler<S>(
     axum::extract::State(service): axum::extract::State<S>,
     Extension(claims): Extension<S::Claims>,
-    Path((group_id, id)): Path<(i64, i64)>,
+    Path((account_id, group_id, id)): Path<(uuid::Uuid, i64, i64)>,
 ) -> impl axum::response::IntoResponse
 where
     S: Server + Clone + Send + Sync + 'static,
     S::Claims: Send + Sync + Clone + 'static,
 {
-    let result = service.subjects_delete(claims, group_id, id).await;
+    let result = service.subjects_delete(claims, account_id, group_id, id).await;
     match result {
         Ok(response) => response.into_response(),
         Err(e) => (
@@ -504,14 +507,14 @@ where
 pub async fn sessions_start_handler<S>(
     axum::extract::State(service): axum::extract::State<S>,
     Extension(claims): Extension<S::Claims>,
-    Path(subject_id): Path<i64>,
+    Path((account_id, subject_id)): Path<(uuid::Uuid, i64)>,
     Json(payload): Json<SessionNoteBody>,
 ) -> impl axum::response::IntoResponse
 where
     S: Server + Clone + Send + Sync + 'static,
     S::Claims: Send + Sync + Clone + 'static,
 {
-    let result = service.sessions_start(claims, subject_id, payload).await;
+    let result = service.sessions_start(claims, account_id, subject_id, payload).await;
     match result {
         Ok(response) => response.into_response(),
         Err(e) => (
@@ -525,13 +528,13 @@ where
 pub async fn sessions_pause_handler<S>(
     axum::extract::State(service): axum::extract::State<S>,
     Extension(claims): Extension<S::Claims>,
-    Path((subject_id, log_id)): Path<(i64, i64)>,
+    Path((account_id, subject_id, log_id)): Path<(uuid::Uuid, i64, i64)>,
 ) -> impl axum::response::IntoResponse
 where
     S: Server + Clone + Send + Sync + 'static,
     S::Claims: Send + Sync + Clone + 'static,
 {
-    let result = service.sessions_pause(claims, subject_id, log_id).await;
+    let result = service.sessions_pause(claims, account_id, subject_id, log_id).await;
     match result {
         Ok(response) => response.into_response(),
         Err(e) => (
@@ -545,13 +548,13 @@ where
 pub async fn sessions_resume_handler<S>(
     axum::extract::State(service): axum::extract::State<S>,
     Extension(claims): Extension<S::Claims>,
-    Path((subject_id, log_id)): Path<(i64, i64)>,
+    Path((account_id, subject_id, log_id)): Path<(uuid::Uuid, i64, i64)>,
 ) -> impl axum::response::IntoResponse
 where
     S: Server + Clone + Send + Sync + 'static,
     S::Claims: Send + Sync + Clone + 'static,
 {
-    let result = service.sessions_resume(claims, subject_id, log_id).await;
+    let result = service.sessions_resume(claims, account_id, subject_id, log_id).await;
     match result {
         Ok(response) => response.into_response(),
         Err(e) => (
@@ -565,14 +568,14 @@ where
 pub async fn sessions_stop_handler<S>(
     axum::extract::State(service): axum::extract::State<S>,
     Extension(claims): Extension<S::Claims>,
-    Path((subject_id, log_id)): Path<(i64, i64)>,
+    Path((account_id, subject_id, log_id)): Path<(uuid::Uuid, i64, i64)>,
     Json(payload): Json<SessionNoteBody>,
 ) -> impl axum::response::IntoResponse
 where
     S: Server + Clone + Send + Sync + 'static,
     S::Claims: Send + Sync + Clone + 'static,
 {
-    let result = service.sessions_stop(claims, subject_id, log_id, payload).await;
+    let result = service.sessions_stop(claims, account_id, subject_id, log_id, payload).await;
     match result {
         Ok(response) => response.into_response(),
         Err(e) => (
@@ -591,24 +594,24 @@ where
 {
     let mut router = Router::new();
     let public = Router::new()
-        .route("/groups", get(groups_list_handler::<S>))
-        .route("/groups/{id}", get(groups_get_by_id_handler::<S>))
-        .route("/groups/{groupId}/subjects", get(subjects_list_handler::<S>))
-        .route("/groups/{groupId}/subjects/{id}", get(subjects_get_by_id_handler::<S>))
+        .route("/accounts/{accountId}/learning/groups", get(groups_list_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>))
         ;
     router = router.merge(public);
     let protected = Router::new()
-        .route("/groups", post(groups_create_handler::<S>))
-        .route("/groups/{id}", patch(groups_update_handler::<S>))
-        .route("/groups/{id}", delete(groups_delete_handler::<S>))
-        .route("/groups/{groupId}/subjects", post(subjects_create_handler::<S>))
-        .route("/groups/{groupId}/subjects/{id}", patch(subjects_update_handler::<S>))
-        .route("/groups/{groupId}/subjects/{id}", delete(subjects_delete_handler::<S>))
-        .route("/subjects/{subjectId}/sessions", post(sessions_start_handler::<S>))
-        .route("/subjects/{subjectId}/sessions/{logId}/pause", post(sessions_pause_handler::<S>))
-        .route("/subjects/{subjectId}/sessions/{logId}/resume", post(sessions_resume_handler::<S>))
-        .route("/subjects/{subjectId}/sessions/{logId}/stop", post(sessions_stop_handler::<S>))
+        .route("/accounts/{accountId}/learning/groups", post(groups_create_handler::<S>))
+        .route("/accounts/{accountId}/learning/groups/{id}", patch(groups_update_handler::<S>))
+        .route("/accounts/{accountId}/learning/groups/{id}", delete(groups_delete_handler::<S>))
+        .route("/accounts/{accountId}/learning/groups/{groupId}/subjects", post(subjects_create_handler::<S>))
+        .route("/accounts/{accountId}/learning/groups/{groupId}/subjects/{id}", patch(subjects_update_handler::<S>))
+        .route("/accounts/{accountId}/learning/groups/{groupId}/subjects/{id}", delete(subjects_delete_handler::<S>))
+        .route("/accounts/{accountId}/learning/subjects/{subjectId}/sessions", post(sessions_start_handler::<S>))
+        .route("/accounts/{accountId}/learning/subjects/{subjectId}/sessions/{logId}/pause", post(sessions_pause_handler::<S>))
+        .route("/accounts/{accountId}/learning/subjects/{subjectId}/sessions/{logId}/resume", post(sessions_resume_handler::<S>))
+        .route("/accounts/{accountId}/learning/subjects/{subjectId}/sessions/{logId}/stop", post(sessions_stop_handler::<S>))
         ;
     router = router.merge(middleware(protected));
     router.with_state(service)
-}
+}

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

@@ -1,3 +1,5 @@
+#![allow(unused)]
+
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize, thiserror::Error)]
 #[error("{code}: {message}")]
 pub struct ApiError {
@@ -49,9 +51,9 @@ pub struct Group {
   #[serde(rename = "accountId")]
   pub account_id: uuid::Uuid,
   #[serde(rename = "createdAt")]
-  pub created_at: String,
+  pub created_at: chrono::DateTime<chrono::Utc>,
   #[serde(rename = "deletedAt")]
-  pub deleted_at: Option<String>,
+  pub deleted_at: Option<chrono::DateTime<chrono::Utc>>,
   pub name: String,
   pub icon: String,
   #[serde(rename = "colorText")]
@@ -66,9 +68,9 @@ pub struct GroupStatistics {
   #[serde(rename = "accountId")]
   pub account_id: uuid::Uuid,
   #[serde(rename = "createdAt")]
-  pub created_at: String,
+  pub created_at: chrono::DateTime<chrono::Utc>,
   #[serde(rename = "deletedAt")]
-  pub deleted_at: Option<String>,
+  pub deleted_at: Option<chrono::DateTime<chrono::Utc>>,
   pub name: String,
   pub icon: String,
   #[serde(rename = "colorText")]
@@ -120,9 +122,9 @@ pub struct Subject {
   #[serde(rename = "groupId")]
   pub group_id: i64,
   #[serde(rename = "createdAt")]
-  pub created_at: String,
+  pub created_at: chrono::DateTime<chrono::Utc>,
   #[serde(rename = "deletedAt")]
-  pub deleted_at: Option<String>,
+  pub deleted_at: Option<chrono::DateTime<chrono::Utc>>,
   pub name: String,
   pub icon: String,
   #[serde(rename = "colorText")]
@@ -139,9 +141,9 @@ pub struct SubjectStatistics {
   #[serde(rename = "groupId")]
   pub group_id: i64,
   #[serde(rename = "createdAt")]
-  pub created_at: String,
+  pub created_at: chrono::DateTime<chrono::Utc>,
   #[serde(rename = "deletedAt")]
-  pub deleted_at: Option<String>,
+  pub deleted_at: Option<chrono::DateTime<chrono::Utc>>,
   pub name: String,
   pub icon: String,
   #[serde(rename = "colorText")]
@@ -191,9 +193,9 @@ pub struct Log {
   #[serde(rename = "subjectId")]
   pub subject_id: i64,
   #[serde(rename = "startedAt")]
-  pub started_at: String,
+  pub started_at: chrono::DateTime<chrono::Utc>,
   #[serde(rename = "stoppedAt")]
-  pub stopped_at: Option<String>,
+  pub stopped_at: Option<chrono::DateTime<chrono::Utc>>,
   #[serde(rename = "logContent")]
   pub log_content: Option<String>,
   pub status: StudyStatus,
@@ -209,9 +211,9 @@ pub struct Timelog {
   #[serde(rename = "subjectId")]
   pub subject_id: i64,
   #[serde(rename = "startedAt")]
-  pub started_at: String,
+  pub started_at: chrono::DateTime<chrono::Utc>,
   #[serde(rename = "stoppedAt")]
-  pub stopped_at: Option<String>,
+  pub stopped_at: Option<chrono::DateTime<chrono::Utc>>,
   #[serde(rename = "durationInSeconds")]
   pub duration_in_seconds: i64,
 }
@@ -291,3 +293,4 @@ impl Default for HexColor {
     Self(String::new())
   }
 }
+

package/example/package-lock.json

@@ -17,7 +17,7 @@
       }
     },
     "..": {
-      "version": "0.4.0",
+      "version": "0.6.0",
       "license": "MIT",
       "devDependencies": {
         "@types/node": "latest",

package/package.json

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